From a6360d11f091e818d749aa29af55d975fb0e64dc Mon Sep 17 00:00:00 2001 From: root Date: Wed, 7 Dec 2022 08:24:37 +0000 Subject: [PATCH 1/2] FIX ICNET --- .../icnet/pytorch/model/__init__.py | 17 + .../model/__pycache__/__init__.cpython-37.pyc | Bin 0 -> 339 bytes .../model/__pycache__/builder.cpython-37.pyc | Bin 0 -> 2695 bytes .../icnet/pytorch/model/builder.py | 5 +- .../icnet/pytorch/model/models/__init__.py | 19 + .../__pycache__/__init__.cpython-37.pyc | Bin 0 -> 230 bytes .../models/__pycache__/icnet.cpython-37.pyc | Bin 0 -> 3329 bytes .../models/__pycache__/segbase.cpython-37.pyc | Bin 0 -> 3750 bytes .../model/models/backbones/__init__.py | 6 + .../__pycache__/__init__.cpython-37.pyc | Bin 0 -> 375 bytes .../__pycache__/build.cpython-37.pyc | Bin 0 -> 1897 bytes .../__pycache__/eespnet.cpython-37.pyc | Bin 0 -> 4680 bytes .../__pycache__/hrnet.cpython-37.pyc | Bin 0 -> 11720 bytes .../__pycache__/mobilenet.cpython-37.pyc | Bin 0 -> 4262 bytes .../__pycache__/resnet.cpython-37.pyc | Bin 0 -> 6599 bytes .../__pycache__/xception.cpython-37.pyc | Bin 0 -> 7599 bytes .../pytorch/model/models/backbones/build.py | 52 ++ .../pytorch/model/models/backbones/eespnet.py | 184 +++++++ .../pytorch/model/models/backbones/hrnet.py | 521 ++++++++++++++++++ .../model/models/backbones/mobilenet.py | 168 ++++++ .../pytorch/model/models/backbones/resnet.py | 263 +++++++++ .../model/models/backbones/xception.py | 297 ++++++++++ .../icnet/pytorch/model/models/icnet.py | 114 ++++ .../icnet/pytorch/model/models/segbase.py | 143 +++++ .../icnet/pytorch/model/modules/__init__.py | 5 + .../__pycache__/__init__.cpython-37.pyc | Bin 0 -> 297 bytes .../modules/__pycache__/basic.cpython-37.pyc | Bin 0 -> 5989 bytes .../__pycache__/batch_norm.cpython-37.pyc | Bin 0 -> 6668 bytes .../modules/__pycache__/module.cpython-37.pyc | Bin 0 -> 7558 bytes .../icnet/pytorch/model/modules/basic.py | 169 ++++++ .../icnet/pytorch/model/modules/batch_norm.py | 183 ++++++ .../icnet/pytorch/model/modules/module.py | 223 ++++++++ .../pytorch/model/modules/sync_bn/syncbn.py | 124 +++++ .../icnet/pytorch/model/utils/__init__.py | 15 + .../utils/__pycache__/__init__.cpython-37.pyc | Bin 0 -> 181 bytes .../__pycache__/distributed.cpython-37.pyc | Bin 0 -> 7644 bytes .../utils/__pycache__/registry.cpython-37.pyc | Bin 0 -> 2260 bytes .../icnet/pytorch/model/utils/distributed.py | 251 +++++++++ .../icnet/pytorch/model/utils/registry.py | 92 ++++ 39 files changed, 2848 insertions(+), 3 deletions(-) create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/__init__.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/__pycache__/__init__.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/__pycache__/builder.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/__init__.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/__init__.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/icnet.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/segbase.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__init__.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/__init__.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/build.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/eespnet.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/hrnet.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/mobilenet.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/resnet.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/xception.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/build.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/eespnet.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/hrnet.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/mobilenet.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/resnet.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/xception.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/icnet.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/segbase.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__init__.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/__init__.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/basic.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/batch_norm.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/module.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/basic.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/batch_norm.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/module.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/sync_bn/syncbn.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/__init__.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/__init__.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/distributed.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/registry.cpython-37.pyc create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/distributed.py create mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/registry.py diff --git a/cv/semantic_segmentation/icnet/pytorch/model/__init__.py b/cv/semantic_segmentation/icnet/pytorch/model/__init__.py new file mode 100644 index 000000000..0f4f51982 --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/__init__.py @@ -0,0 +1,17 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/__init__.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c91f0abc7c32afb5fd0b3bfc6c49646400effe3f GIT binary patch literal 339 zcmYjLO-jTt82ysgsT4-gm3V`0CLUlAQCBY9xDi1@CJk+9n${-cSg5P<0D6O&rB}+< zBeJ!HngU|D{g6iy!1vhv0eiSax>J-Ka`Fxe*03R4xPdi!q&dBZ zERqD*BPj9!d5v^uC2r)t4Rm%MNc9EX z=(2lYWm7Bmss$E3TM1jRT&dQzqN~c~g2@-=R4uI6k~>w@%6j2-W0{s#dDiy6>14_3 zCRc`WuC4Z*&)R;M&W(0nHg$V(JZ2q(PoPV%++|Tn3ezlvaUrf$??S@4FoyGes(&)U Q^Kdvv`=wEPqaU2WFKp6Q4gdfE literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/builder.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/builder.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..395b7c070d27e5eccba5a31220ce1115b3d97a23 GIT binary patch literal 2695 zcmZuz&2!tv72gFw5~3tpmKE7f-GoV%CP-7!k<*)N8zff}BM{^epjGcQv!S>!O`9Jw z0QzgFPFwlV3p?pC>2$_9_Mhmz{{l{($w{}KbLx8w>LZ>mX5a4nz`lLIefxm&@^YR) zn|}FC_g|}o{D919`w%AgphxdgLL`xNKztI=fJ#m3GaL>gD@Az=H@{NxG{-!iz__L#7}W|J3~YnL4+s;ttevKC)Oso1aiyTW5lQE9mM`Py75 z@U2s6VjOg$0KDZI6=An3yS?we#rE&Jmd=+hHDGLZ;lZ-O4U-dBvgYxu&vfyDoD)o>3d(i`y7- zo%y?s>WOk?pqC8zuT@U|2=fyH&|4k=`8-qE!C|4a5pr?z2{sQE_wuyR(Mbdk=ba4M;#Z+(51c`eTD2869@QCyyovrS7v*6bw6~xZed&y-sgiUN5Nvo=P*Z^( zwSdHAN@9Afh1Vn$!Pmf5$uWSV)=Kzd;I)zT4#<>@i~oA%W3QbeHEn27Aw_~0=djJA0* zp)bw>3*U#Af6U(=^rN^t9v5H4U2jgyM5Z!^vsiBog^8KhkisH_w z8zcrQ!t3y&0wyfN%+eDb+$M(TKI|p*$y;uf%>?WsEO~_HX#si``WiJfrS0NQuwk$n z=nCIIz+_6_kna({!zp<~zefz^@3kZCNRPFt4%lkZ=2V{}xjNOR^hqwfcP;@dK>0dR zmNGUZjWd5IQu~KK)z;w*{!E{)#@W;!&O}+mnXIN~0%!56@L)VC4kuAugp4hI{c7X4 zemDufF2>{HL&%|^*clba&w}uI2jq+z8{uA_Q z9SET&T?K^mFe2VdG_S4G5N&>vT$s-aYh3g!mp5YVjgF|RT!rjDB5`I4XdS66wWw=l zFN9R^*bdgPR>KvQ?VZqqwUnzgJD}2ZRhi%>exWc)-r9R|Ro%eTiyDqcB7Nf+p2Lp=!0>sqNRaQ~$yru3_DeCpK nD_fYKON^gb8Wef7RyJ_y&p8a^oWoSr=vrg`kf*P+0$%mO37#@Q-FaYE;H~?|60FX#wh+;@#Okv7l3}HxN4rb6~sp9m_ zPf5*Dh|14@$p}=T$#{!V%TJT(7JGbrN`7*Dd=zVDa$ai5N`@j9pfs5H6|bL>pPQ;* zk(mgjGWE(6^V0QGQd0|x3lfX6GfI>6lgsprQ*#sZN-~qN!AD literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/icnet.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/icnet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f2cfe75374fd357e84e677b8aa5c3cecbae7a53 GIT binary patch literal 3329 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 It`HLb7jHg=tpET3 literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__init__.py b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__init__.py new file mode 100644 index 000000000..3062701f2 --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__init__.py @@ -0,0 +1,6 @@ +from .build import BACKBONE_REGISTRY, get_segmentation_backbone +from .xception import * +from .mobilenet import * +from .resnet import * +from .hrnet import * +from .eespnet import * diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/__init__.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ebaf000172bfa4d351758684e7abeda95b0bf21 GIT binary patch literal 375 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 literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/hrnet.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/hrnet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c397e29c766a995da6508ab22fc763c1749a0753 GIT binary patch literal 11720 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 NzcBs_#Jp~@{{Y9)(=z}7 literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/resnet.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/resnet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91dcaba7e366127e63bda1640ea84b6e47640aec GIT binary patch literal 6599 zcmb_g&2QYs73c74xu5#9Vmpqb*ol*M3(1o0HYk$RmhGfYZ8?zTxE0zm)D9(awaZ-( zDOpyjqKE?Iq{1hkrS{ZokNpSw5A-yLqG*Al0($DH2#TV=H(XL$Id+1?yWnv6=FQCG z%zMB2JSvfw5>aZM02gAkm%dcbnV#K zEpT&>>WxApmTv`p>r=+nMPDyjlzjaTV!f&mm z@@bM!%M$NA3?r}IZTZrUVi9n^?npE8TT9Xj!fwk8{YcvBU5sKfLCYjYXxgE!@YjRR zTI6QN$x_%6ZMWq;@&#U@=(>%T7e%i7d+m$m$(2sqpWFyM+=7XRUbsBTeZL!ZJ+Zp7 zwm8{XpN#yr7sf%ujr`@dAI9p9Cxb@l$CKShaYr;(CfgnEx6(42T=W{NiyhcFDf|dp z6WvFGLi7}_h|JaW8mq7xE2*-AyUjMo`rKe5TfGMP1N|tJX&bKLiatS+uq{2&c5&Zh zTiC5#_&~3w=QSg*nOUuAac#9IK12^o^@Vn#e_vB$WIYY+JDaWBqKcVBjfz1khNu{( zf>yh3ietD*wt(^aQWtAsR!WF;g$$#Ybq1X1|O(oaGYOl4ZUUA(AYhJ6@QuH^vUKo)-mTA)Rj2AanX0iFxTy20D zCvmms01dy@a@_+<>r9+PyC8#=3!gwGBF}PQtj$I%O4@)R|2-Q4bP7eTA3^|=TM7Ye zUieHqga8f@pcBU}KlBv>?9)y^4+fr~{aG-e0Ki1(_5lDuf`T3{&<7HQJm_;^NVH~g z6nLJGQzD&Is^FvyIH_<;!AVs?MNL7)fPxBpRv8YcP>>*Om^xn{6a-=7O)4l5)b@x9 z)ehY2z_VUQLkb8N2@o!d0n$|NM^2|AzV0Z`6XZ+crA&H&1L8QzXa}=x&7D!1@I$nu zj)+(s?L}gVon(WENfnKUx8y6L@mCn^n?~bq7I74fS^U~rtyxg9x`J3Od{wMEhZgfl ztWwyC^Hdy)TJZ`APE+wJ75yQrV&yjE5yeAaxIP`UeQT8mt$2-wJwwG=DrjHRt$%}R z$`i(^c8-dC`fS5g9FotxgX?e{R+T4xc^v)-x(6q*ib2E2A=x{H(-;KL0n33D5z3Y< z#c~+V<{~fkMP^x0D9#4|G;sRmM>2sStuKUH^f$nBVl=fT+j7)h-zp{!XREq6kJ4^ts>H?JQe147c`>Qr&45M3&US3Xb7h;MwZbcVxHrp5MQIRX zJzGP=u~DQqN_F;#WK_eGy&0&riaD@?Y7Vqv9!Qm?wQM%@89;q7wP%kg#t^iI6TD$& zIdH0WLQ4vKV25yQByTVD-W)cZ(6|AO!5yM1qq)XVu3=z=vKpt<8*LbGuDQo@-H}|k zsB|%AQlgPzH|^(`DqrHGI}Z9ChkYXnYn~X@^7Y5N@4n2BDI`3F`YTWAn0r7@_w)uw z_`bTQUDtm8ldWnzo>Xbow)Mxlm_zNg=9#40Jj=mV`SBg_@o=K2^SaVGPddAAC>?!I z2kFb6&+!^PKh__dzpo`W#{0|0NBLaWdvm?1M)_mj>n+Ts`h};}JayInByT^TwPV~T z_mMS#3Y?hTABVduaNj3JvQH7PuV~j>RQoj*S5PR(&+vbKpNOGId3B1$dP>*`nfKwf zTHQFr;7A&17{6{Ek;+ngtrZ9EGT5N3rS**9)pcc;D!??n&?N>!27;rSM9pL+?1Zf# z^gRKFQvZ&$Zr{0n9L~@HFa3$hng(i^&hMe5%OB;0jJKcgHw*IlEvHJ#z&n_3w*fH_BOhx%Cg(` zR{fNvN?VcDsos6McfTl0x9{DWzv+GeYh^91U%z?l>io?+vpt7$UH0=uZGeuHcb9FllH$v20xgfgcV%6%K;Q}m-lhDhu+T+t_p6RzQ4 zF>$aM(J6qK22#eFY*bq{#D}rIYs5N8-XS?M!ZaJCJg=v_&Gv9SEo)mKb{2k@v2bQV=;HMeovZM2e;Db-RAZWo2#+NYeIG z;IToh+FmRTWD3#}NLBq_Jc&8#N-S8~Dzc&@=qWCe!X+xyJKQBzg9q!91(F@gfzssX z3Yve1E21769RE069@N+{ad+4-+*pJ-P|c2LnnNYKIGuC3ED}O1|2nc1(g8B#L&wzH z5*;JztpO%Q6ZhxZMJe)8yG&)5HLHk(im`oqov&k|2%z{3+b&-ED;f`MYvJhy*d|sn z&X?Inr{Ce#d!B8VFZ`p=w)Ts$ZJ!X~8{1aw?dgT7fAtyH`S!+5V2J(KUxaa&r~ln& z+=HXW5&u+?KzVNZS>tJs!&zq`7VzMueH0q6})_*@gHW4}TKX-Dwvw=GIRMiXDG(E82?7T}Q7FjU1$mXAT@$n@ og62GgGC7Tu&O0f0eveLsh^TKx$KhxUpB;W{c->~h*0Znw1N9JDT>t<8 literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/xception.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/xception.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84eafb57b1a0c3a7d4e911189fe885c03c2fb612 GIT binary patch literal 7599 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 base else base_s + else: + out_channels[i] = base_s * pow(2, i) + if scale <= 1.5: + out_channels.append(1024) + elif scale in [1.5, 2]: + out_channels.append(1280) + else: + raise ValueError("Unknown scale value.") + + self.level1 = _ConvBNPReLU(3, out_channels[0], 3, 2, 1, norm_layer=norm_layer) + + self.level2_0 = DownSampler(out_channels[0], out_channels[1], k=K[0], r_lim=r_lim[0], + reinf=reinf, inp_reinf=inp_reinf, norm_layer=norm_layer) + + self.level3_0 = DownSampler(out_channels[1], out_channels[2], k=K[1], r_lim=r_lim[1], + reinf=reinf, inp_reinf=inp_reinf, norm_layer=norm_layer) + self.level3 = nn.ModuleList() + for i in range(reps[1]): + self.level3.append(EESP(out_channels[2], out_channels[2], k=K[2], r_lim=r_lim[2], + norm_layer=norm_layer)) + + self.level4_0 = DownSampler(out_channels[2], out_channels[3], k=K[2], r_lim=r_lim[2], + reinf=reinf, inp_reinf=inp_reinf, norm_layer=norm_layer) + self.level4 = nn.ModuleList() + for i in range(reps[2]): + self.level4.append(EESP(out_channels[3], out_channels[3], k=K[3], r_lim=r_lim[3], + norm_layer=norm_layer)) + + self.level5_0 = DownSampler(out_channels[3], out_channels[4], k=K[3], r_lim=r_lim[3], + reinf=reinf, inp_reinf=inp_reinf, norm_layer=norm_layer) + self.level5 = nn.ModuleList() + for i in range(reps[2]): + self.level5.append(EESP(out_channels[4], out_channels[4], k=K[4], r_lim=r_lim[4], + norm_layer=norm_layer)) + + self.level5.append(_ConvBNPReLU(out_channels[4], out_channels[4], 3, 1, 1, + groups=out_channels[4], norm_layer=norm_layer)) + self.level5.append(_ConvBNPReLU(out_channels[4], out_channels[5], 1, 1, 0, + groups=K[4], norm_layer=norm_layer)) + + self.fc = nn.Linear(out_channels[5], num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + if m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Linear): + nn.init.normal_(m.weight, std=0.001) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x, seg=True): + out_l1 = self.level1(x) + + out_l2 = self.level2_0(out_l1, x) + + out_l3_0 = self.level3_0(out_l2, x) + for i, layer in enumerate(self.level3): + if i == 0: + out_l3 = layer(out_l3_0) + else: + out_l3 = layer(out_l3) + + out_l4_0 = self.level4_0(out_l3, x) + for i, layer in enumerate(self.level4): + if i == 0: + out_l4 = layer(out_l4_0) + else: + out_l4 = layer(out_l4) + + if not seg: + out_l5_0 = self.level5_0(out_l4) # down-sampled + for i, layer in enumerate(self.level5): + if i == 0: + out_l5 = layer(out_l5_0) + else: + out_l5 = layer(out_l5) + + output_g = F.adaptive_avg_pool2d(out_l5, output_size=1) + output_g = F.dropout(output_g, p=0.2, training=self.training) + output_1x1 = output_g.view(output_g.size(0), -1) + + return self.fc(output_1x1) + return out_l1, out_l2, out_l3, out_l4 + + +@BACKBONE_REGISTRY.register() +def eespnet(cfg=None, norm_layer=nn.BatchNorm2d): + return EESPNet(cfg=cfg, norm_layer=norm_layer) + +# def eespnet(pretrained=False, **kwargs): +# model = EESPNet(**kwargs) +# if pretrained: +# raise ValueError("Don't support pretrained") +# return model + + +if __name__ == '__main__': + img = torch.randn(1, 3, 224, 224) + model = eespnet() + out = model(img) diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/hrnet.py b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/hrnet.py new file mode 100644 index 000000000..fb6936b9c --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/hrnet.py @@ -0,0 +1,521 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + + +# this code is heavily based on https://github.com/HRNet + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import os +import logging + +import torch +import torch.nn as nn +import torch._utils +import numpy as np + +from .build import BACKBONE_REGISTRY + + +def conv3x3(in_planes, out_planes, stride=1): + """3x3 convolution with padding""" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(BasicBlock, self).__init__() + self.conv1 = conv3x3(inplanes, planes, stride) + self.bn1 = nn.BatchNorm2d(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes) + self.bn2 = nn.BatchNorm2d(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, + padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, + bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class HighResolutionModule(nn.Module): + def __init__(self, num_branches, blocks, num_blocks, num_inchannels, + num_channels, fuse_method, multi_scale_output=True): + super(HighResolutionModule, self).__init__() + self._check_branches( + num_branches, blocks, num_blocks, num_inchannels, num_channels) + + self.num_inchannels = num_inchannels + self.fuse_method = fuse_method + self.num_branches = num_branches + + self.multi_scale_output = multi_scale_output + + self.branches = self._make_branches( + num_branches, blocks, num_blocks, num_channels) + self.fuse_layers = self._make_fuse_layers() + self.relu = nn.ReLU(False) + + def _check_branches(self, num_branches, blocks, num_blocks, + num_inchannels, num_channels): + if num_branches != len(num_blocks): + error_msg = 'NUM_BRANCHES({}) <> NUM_BLOCKS({})'.format( + num_branches, len(num_blocks)) + logging.error(error_msg) + raise ValueError(error_msg) + + if num_branches != len(num_channels): + error_msg = 'NUM_BRANCHES({}) <> NUM_CHANNELS({})'.format( + num_branches, len(num_channels)) + logging.error(error_msg) + raise ValueError(error_msg) + + if num_branches != len(num_inchannels): + error_msg = 'NUM_BRANCHES({}) <> NUM_INCHANNELS({})'.format( + num_branches, len(num_inchannels)) + logging.error(error_msg) + raise ValueError(error_msg) + + def _make_one_branch(self, branch_index, block, num_blocks, num_channels, + stride=1): + downsample = None + if stride != 1 or \ + self.num_inchannels[branch_index] != num_channels[branch_index] * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.num_inchannels[branch_index], + num_channels[branch_index] * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm2d(num_channels[branch_index] * block.expansion), + ) + + layers = [] + layers.append(block(self.num_inchannels[branch_index], + num_channels[branch_index], stride, downsample)) + self.num_inchannels[branch_index] = \ + num_channels[branch_index] * block.expansion + for i in range(1, num_blocks[branch_index]): + layers.append(block(self.num_inchannels[branch_index], + num_channels[branch_index])) + + return nn.Sequential(*layers) + + def _make_branches(self, num_branches, block, num_blocks, num_channels): + branches = [] + + for i in range(num_branches): + branches.append( + self._make_one_branch(i, block, num_blocks, num_channels)) + + return nn.ModuleList(branches) + + def _make_fuse_layers(self): + if self.num_branches == 1: + return None + + num_branches = self.num_branches + num_inchannels = self.num_inchannels + fuse_layers = [] + for i in range(num_branches if self.multi_scale_output else 1): + fuse_layer = [] + for j in range(num_branches): + if j > i: + fuse_layer.append(nn.Sequential( + nn.Conv2d(num_inchannels[j], + num_inchannels[i], + 1, + 1, + 0, + bias=False), + nn.BatchNorm2d(num_inchannels[i]), + nn.Upsample(scale_factor=2 ** (j - i), mode='nearest'))) + elif j == i: + fuse_layer.append(None) + else: + conv3x3s = [] + for k in range(i - j): + if k == i - j - 1: + num_outchannels_conv3x3 = num_inchannels[i] + conv3x3s.append(nn.Sequential( + nn.Conv2d(num_inchannels[j], + num_outchannels_conv3x3, + 3, 2, 1, bias=False), + nn.BatchNorm2d(num_outchannels_conv3x3))) + else: + num_outchannels_conv3x3 = num_inchannels[j] + conv3x3s.append(nn.Sequential( + nn.Conv2d(num_inchannels[j], + num_outchannels_conv3x3, + 3, 2, 1, bias=False), + nn.BatchNorm2d(num_outchannels_conv3x3), + nn.ReLU(False))) + fuse_layer.append(nn.Sequential(*conv3x3s)) + fuse_layers.append(nn.ModuleList(fuse_layer)) + + return nn.ModuleList(fuse_layers) + + def get_num_inchannels(self): + return self.num_inchannels + + def forward(self, x): + if self.num_branches == 1: + return [self.branches[0](x[0])] + + for i in range(self.num_branches): + x[i] = self.branches[i](x[i]) + + x_fuse = [] + for i in range(len(self.fuse_layers)): + y = x[0] if i == 0 else self.fuse_layers[i][0](x[0]) + for j in range(1, self.num_branches): + if i == j: + y = y + x[j] + else: + y = y + self.fuse_layers[i][j](x[j]) + x_fuse.append(self.relu(y)) + + return x_fuse + + +blocks_dict = { + 'BASIC': BasicBlock, + 'BOTTLENECK': Bottleneck +} + + +class HighResolutionNet(nn.Module): + + def __init__(self, cfg=None, norm_layer=nn.BatchNorm2d): + super(HighResolutionNet, self).__init__() + + self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, + bias=False) + self.bn1 = norm_layer(64) + self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=2, padding=1, + bias=False) + self.bn2 = norm_layer(64) + self.relu = nn.ReLU(inplace=True) + + self.stage1_cfg = cfg.MODEL.HRNET.STAGE1 + num_channels = self.stage1_cfg['NUM_CHANNELS'][0] + block = blocks_dict[self.stage1_cfg['BLOCK']] + num_blocks = self.stage1_cfg['NUM_BLOCKS'][0] + self.layer1 = self._make_layer(block, 64, num_channels, num_blocks, norm_layer=norm_layer) + stage1_out_channel = block.expansion * num_channels + + self.stage2_cfg = cfg.MODEL.HRNET.STAGE2 + num_channels = self.stage2_cfg['NUM_CHANNELS'] + block = blocks_dict[self.stage2_cfg['BLOCK']] + num_channels = [ + num_channels[i] * block.expansion for i in range(len(num_channels))] + self.transition1 = self._make_transition_layer( + [stage1_out_channel], num_channels, norm_layer=norm_layer) + self.stage2, pre_stage_channels = self._make_stage( + self.stage2_cfg, num_channels) + + self.stage3_cfg = cfg.MODEL.HRNET.STAGE3 + num_channels = self.stage3_cfg['NUM_CHANNELS'] + block = blocks_dict[self.stage3_cfg['BLOCK']] + num_channels = [ + num_channels[i] * block.expansion for i in range(len(num_channels))] + self.transition2 = self._make_transition_layer( + pre_stage_channels, num_channels) + self.stage3, pre_stage_channels = self._make_stage( + self.stage3_cfg, num_channels) + + self.stage4_cfg = cfg.MODEL.HRNET.STAGE4 + num_channels = self.stage4_cfg['NUM_CHANNELS'] + block = blocks_dict[self.stage4_cfg['BLOCK']] + num_channels = [ + num_channels[i] * block.expansion for i in range(len(num_channels))] + self.transition3 = self._make_transition_layer( + pre_stage_channels, num_channels) + self.stage4, pre_stage_channels = self._make_stage( + self.stage4_cfg, num_channels, multi_scale_output=True) + + self.last_inp_channels = np.int(np.sum(pre_stage_channels)) + # Classification Head + # self.incre_modules, self.downsamp_modules, \ + # self.final_layer = self._make_head(pre_stage_channels) + # + # self.classifier = nn.Linear(2048, 1000) + + def _make_head(self, pre_stage_channels): + head_block = Bottleneck + head_channels = [32, 64, 128, 256] + + # Increasing the #channels on each resolution + # from C, 2C, 4C, 8C to 128, 256, 512, 1024 + incre_modules = [] + for i, channels in enumerate(pre_stage_channels): + incre_module = self._make_layer(head_block, + channels, + head_channels[i], + 1, + stride=1) + incre_modules.append(incre_module) + incre_modules = nn.ModuleList(incre_modules) + + # downsampling modules + downsamp_modules = [] + for i in range(len(pre_stage_channels) - 1): + in_channels = head_channels[i] * head_block.expansion + out_channels = head_channels[i + 1] * head_block.expansion + + downsamp_module = nn.Sequential( + nn.Conv2d(in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=2, + padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU(inplace=True) + ) + + downsamp_modules.append(downsamp_module) + downsamp_modules = nn.ModuleList(downsamp_modules) + + final_layer = nn.Sequential( + nn.Conv2d( + in_channels=head_channels[3] * head_block.expansion, + out_channels=2048, + kernel_size=1, + stride=1, + padding=0 + ), + nn.BatchNorm2d(2048), + nn.ReLU(inplace=True) + ) + + return incre_modules, downsamp_modules, final_layer + + def _make_transition_layer(self, num_channels_pre_layer, num_channels_cur_layer, + norm_layer=nn.BatchNorm2d): + num_branches_cur = len(num_channels_cur_layer) + num_branches_pre = len(num_channels_pre_layer) + + transition_layers = [] + for i in range(num_branches_cur): + if i < num_branches_pre: + if num_channels_cur_layer[i] != num_channels_pre_layer[i]: + transition_layers.append(nn.Sequential( + nn.Conv2d(num_channels_pre_layer[i], + num_channels_cur_layer[i], + 3, + 1, + 1, + bias=False), + norm_layer( + num_channels_cur_layer[i]), + nn.ReLU(inplace=True))) + else: + transition_layers.append(None) + else: + conv3x3s = [] + for j in range(i + 1 - num_branches_pre): + inchannels = num_channels_pre_layer[-1] + outchannels = num_channels_cur_layer[i] \ + if j == i - num_branches_pre else inchannels + conv3x3s.append(nn.Sequential( + nn.Conv2d( + inchannels, outchannels, 3, 2, 1, bias=False), + norm_layer(outchannels), + nn.ReLU(inplace=True))) + transition_layers.append(nn.Sequential(*conv3x3s)) + + return nn.ModuleList(transition_layers) + + def _make_layer(self, block, inplanes, planes, blocks, stride=1, norm_layer=nn.BatchNorm2d): + downsample = None + if stride != 1 or inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + norm_layer(planes * block.expansion), + ) + + layers = [] + layers.append(block(inplanes, planes, stride, downsample)) + inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(inplanes, planes)) + + return nn.Sequential(*layers) + + def _make_stage(self, layer_config, num_inchannels, + multi_scale_output=True): + num_modules = layer_config['NUM_MODULES'] + num_branches = layer_config['NUM_BRANCHES'] + num_blocks = layer_config['NUM_BLOCKS'] + num_channels = layer_config['NUM_CHANNELS'] + block = blocks_dict[layer_config['BLOCK']] + fuse_method = layer_config['FUSE_METHOD'] + + modules = [] + for i in range(num_modules): + # multi_scale_output is only used last module + if not multi_scale_output and i == num_modules - 1: + reset_multi_scale_output = False + else: + reset_multi_scale_output = True + + modules.append( + HighResolutionModule(num_branches, + block, + num_blocks, + num_inchannels, + num_channels, + fuse_method, + reset_multi_scale_output) + ) + num_inchannels = modules[-1].get_num_inchannels() + + return nn.Sequential(*modules), num_inchannels + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.conv2(x) + x = self.bn2(x) + x = self.relu(x) + x = self.layer1(x) + + x_list = [] + for i in range(self.stage2_cfg['NUM_BRANCHES']): + if self.transition1[i] is not None: + x_list.append(self.transition1[i](x)) + else: + x_list.append(x) + y_list = self.stage2(x_list) + + x_list = [] + for i in range(self.stage3_cfg['NUM_BRANCHES']): + if self.transition2[i] is not None: + x_list.append(self.transition2[i](y_list[-1])) + else: + x_list.append(y_list[i]) + y_list = self.stage3(x_list) + + x_list = [] + for i in range(self.stage4_cfg['NUM_BRANCHES']): + if self.transition3[i] is not None: + x_list.append(self.transition3[i](y_list[-1])) + else: + x_list.append(y_list[i]) + y_list = self.stage4(x_list) + + # Classification Head + # y = self.incre_modules[0](y_list[0]) + # for i in range(len(self.downsamp_modules)): + # y = self.incre_modules[i + 1](y_list[i + 1]) + \ + # self.downsamp_modules[i](y) + # + # y = self.final_layer(y) + # + # if torch._C._get_tracing_state(): + # y = y.flatten(start_dim=2).mean(dim=2) + # else: + # y = F.avg_pool2d(y, kernel_size=y.size() + # [2:]).view(y.size(0), -1) + # + # y = self.classifier(y) + + return tuple(y_list) + + def init_weights(self, pretrained='', ): + logging.info('=> init weights from normal distribution') + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_( + m.weight, mode='fan_out', nonlinearity='relu') + elif isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + if os.path.isfile(pretrained): + pretrained_dict = torch.load(pretrained) + logging.info('=> loading pretrained model {}'.format(pretrained)) + model_dict = self.state_dict() + pretrained_dict = {k: v for k, v in pretrained_dict.items() + if k in model_dict.keys()} + for k, _ in pretrained_dict.items(): + logging.info( + '=> loading {} pretrained model {}'.format(k, pretrained)) + model_dict.update(pretrained_dict) + self.load_state_dict(model_dict) + + +@BACKBONE_REGISTRY.register() +def hrnetv1_w18_small(cfg=None, norm_layer=nn.BatchNorm2d): + return HighResolutionNet(cfg=cfg, norm_layer=norm_layer) diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/mobilenet.py b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/mobilenet.py new file mode 100644 index 000000000..3541a4cde --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/mobilenet.py @@ -0,0 +1,168 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + +"""MobileNet and MobileNetV2.""" +import torch.nn as nn + +from .build import BACKBONE_REGISTRY +from ...modules import _ConvBNReLU, _DepthwiseConv, InvertedResidual + +__all__ = ['MobileNet', 'MobileNetV2'] + + +class MobileNet(nn.Module): + def __init__(self, cfg=None, num_classes=1000, norm_layer=nn.BatchNorm2d): + super(MobileNet, self).__init__() + multiplier = cfg.MODEL.BACKBONE_SCALE + conv_dw_setting = [ + [64, 1, 1], + [128, 2, 2], + [256, 2, 2], + [512, 6, 2], + [1024, 2, 2]] + input_channels = int(32 * multiplier) if multiplier > 1.0 else 32 + features = [_ConvBNReLU(3, input_channels, 3, 2, 1, norm_layer=norm_layer)] + + for c, n, s in conv_dw_setting: + out_channels = int(c * multiplier) + for i in range(n): + stride = s if i == 0 else 1 + features.append(_DepthwiseConv(input_channels, out_channels, stride, norm_layer)) + input_channels = out_channels + self.last_inp_channels = int(1024 * multiplier) + features.append(nn.AdaptiveAvgPool2d(1)) + self.features = nn.Sequential(*features) + + self.classifier = nn.Linear(int(1024 * multiplier), num_classes) + + # weight initialization + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out') + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, nn.BatchNorm2d): + nn.init.ones_(m.weight) + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Linear): + nn.init.normal_(m.weight, 0, 0.01) + nn.init.zeros_(m.bias) + + def forward(self, x): + x = self.features(x) + x = self.classifier(x.view(x.size(0), x.size(1))) + return x + + +class MobileNetV2(nn.Module): + def __init__(self, cfg=None, num_classes=1000, norm_layer=nn.BatchNorm2d): + super(MobileNetV2, self).__init__() + output_stride = cfg.MODEL.OUTPUT_STRIDE + self.multiplier = cfg.MODEL.BACKBONE_SCALE + if output_stride == 32: + dilations = [1, 1] + elif output_stride == 16: + dilations = [1, 2] + elif output_stride == 8: + dilations = [2, 4] + else: + raise NotImplementedError + inverted_residual_setting = [ + # t, c, n, s + [1, 16, 1, 1], + [6, 24, 2, 2], + [6, 32, 3, 2], + [6, 64, 4, 2], + [6, 96, 3, 1], + [6, 160, 3, 2], + [6, 320, 1, 1]] + # building first layer + input_channels = int(32 * self.multiplier) if self.multiplier > 1.0 else 32 + # last_channels = int(1280 * multiplier) if multiplier > 1.0 else 1280 + self.conv1 = _ConvBNReLU(3, input_channels, 3, 2, 1, relu6=True, norm_layer=norm_layer) + + # building inverted residual blocks + self.planes = input_channels + self.block1 = self._make_layer(InvertedResidual, self.planes, inverted_residual_setting[0:1], + norm_layer=norm_layer) + self.block2 = self._make_layer(InvertedResidual, self.planes, inverted_residual_setting[1:2], + norm_layer=norm_layer) + self.block3 = self._make_layer(InvertedResidual, self.planes, inverted_residual_setting[2:3], + norm_layer=norm_layer) + self.block4 = self._make_layer(InvertedResidual, self.planes, inverted_residual_setting[3:5], + dilations[0], norm_layer=norm_layer) + self.block5 = self._make_layer(InvertedResidual, self.planes, inverted_residual_setting[5:], + dilations[1], norm_layer=norm_layer) + self.last_inp_channels = self.planes + + # building last several layers + # features = list() + # features.append(_ConvBNReLU(input_channels, last_channels, 1, relu6=True, norm_layer=norm_layer)) + # features.append(nn.AdaptiveAvgPool2d(1)) + # self.features = nn.Sequential(*features) + # + # self.classifier = nn.Sequential( + # nn.Dropout2d(0.2), + # nn.Linear(last_channels, num_classes)) + + # weight initialization + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out') + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, nn.BatchNorm2d): + nn.init.ones_(m.weight) + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Linear): + nn.init.normal_(m.weight, 0, 0.01) + if m.bias is not None: + nn.init.zeros_(m.bias) + + def _make_layer(self, block, planes, inverted_residual_setting, dilation=1, norm_layer=nn.BatchNorm2d): + features = list() + for t, c, n, s in inverted_residual_setting: + out_channels = int(c * self.multiplier) + stride = s if dilation == 1 else 1 + features.append(block(planes, out_channels, stride, t, dilation, norm_layer)) + planes = out_channels + for i in range(n - 1): + features.append(block(planes, out_channels, 1, t, norm_layer=norm_layer)) + planes = out_channels + self.planes = planes + return nn.Sequential(*features) + + def forward(self, x): + x = self.conv1(x) + x = self.block1(x) + c1 = self.block2(x) + c2 = self.block3(c1) + c3 = self.block4(c2) + c4 = self.block5(c3) + + # x = self.features(x) + # x = self.classifier(x.view(x.size(0), x.size(1))) + return c1, c2, c3, c4 + + +@BACKBONE_REGISTRY.register() +def mobilenet_v1(cfg=None, norm_layer=nn.BatchNorm2d): + return MobileNet(cfg=cfg, norm_layer=norm_layer) + + +@BACKBONE_REGISTRY.register() +def mobilenet_v2(cfg=None, norm_layer=nn.BatchNorm2d): + return MobileNetV2(cfg=cfg, norm_layer=norm_layer) diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/resnet.py b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/resnet.py new file mode 100644 index 000000000..b62d8dfda --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/resnet.py @@ -0,0 +1,263 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + + +import torch.nn as nn + +from .build import BACKBONE_REGISTRY + +__all__ = ['ResNetV1'] + + +class BasicBlockV1b(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, + previous_dilation=1, norm_layer=nn.BatchNorm2d): + super(BasicBlockV1b, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, 3, stride, + dilation, dilation, bias=False) + self.bn1 = norm_layer(planes) + self.relu = nn.ReLU(True) + self.conv2 = nn.Conv2d(planes, planes, 3, 1, previous_dilation, + dilation=previous_dilation, bias=False) + self.bn2 = norm_layer(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + identity = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu(out) + + return out + + +class BottleneckV1b(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, + previous_dilation=1, norm_layer=nn.BatchNorm2d): + super(BottleneckV1b, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = norm_layer(planes) + self.conv2 = nn.Conv2d(planes, planes, 3, stride, + dilation, dilation, bias=False) + self.bn2 = norm_layer(planes) + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = norm_layer(planes * self.expansion) + self.relu = nn.ReLU(True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + identity = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu(out) + + return out + + +class ResNetV1(nn.Module): + + def __init__(self, block, layers, cfg=None, num_classes=1000, deep_stem=False, + zero_init_residual=False, norm_layer=nn.BatchNorm2d): + output_stride = cfg.MODEL.OUTPUT_STRIDE + scale = cfg.MODEL.BACKBONE_SCALE + if output_stride == 32: + dilations = [1, 1] + strides = [2, 2] + elif output_stride == 16: + dilations = [1, 2] + strides = [2, 1] + elif output_stride == 8: + dilations = [2, 4] + strides = [1, 1] + else: + raise NotImplementedError + self.inplanes = int((128 if deep_stem else 64) * scale) + super(ResNetV1, self).__init__() + if deep_stem: + # resnet vc + mid_channel = int(64 * scale) + self.conv1 = nn.Sequential( + nn.Conv2d(3, mid_channel, 3, 2, 1, bias=False), + norm_layer(mid_channel), + nn.ReLU(True), + nn.Conv2d(mid_channel, mid_channel, 3, 1, 1, bias=False), + norm_layer(mid_channel), + nn.ReLU(True), + nn.Conv2d(mid_channel, self.inplanes, 3, 1, 1, bias=False) + ) + else: + self.conv1 = nn.Conv2d(3, self.inplanes, 7, 2, 3, bias=False) + self.bn1 = norm_layer(self.inplanes) + self.relu = nn.ReLU(True) + self.maxpool = nn.MaxPool2d(3, 2, 1) + self.layer1 = self._make_layer(block, int(64 * scale), layers[0], norm_layer=norm_layer) + self.layer2 = self._make_layer(block, int(128 * scale), layers[1], stride=2, norm_layer=norm_layer) + + self.layer3 = self._make_layer(block, int(256 * scale), layers[2], stride=strides[0], dilation=dilations[0], + norm_layer=norm_layer) + self.layer4 = self._make_layer(block, int(512 * scale), layers[3], stride=strides[1], dilation=dilations[1], + norm_layer=norm_layer, multi_grid=cfg.MODEL.MULTI_GRID, + multi_dilation=cfg.MODEL.MULTI_DILATION) + + self.last_inp_channels = int(512 * block.expansion * scale) + self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) + self.fc = nn.Linear(int(512 * block.expansion * scale), num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + elif isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + + if zero_init_residual: + for m in self.modules(): + if isinstance(m, BottleneckV1b): + nn.init.constant_(m.bn3.weight, 0) + elif isinstance(m, BasicBlockV1b): + nn.init.constant_(m.bn2.weight, 0) + + def _make_layer(self, block, planes, blocks, stride=1, dilation=1, norm_layer=nn.BatchNorm2d, + multi_grid=False, multi_dilation=None): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.inplanes, planes * block.expansion, 1, stride, bias=False), + norm_layer(planes * block.expansion), + ) + + layers = [] + if not multi_grid: + if dilation in (1, 2): + layers.append(block(self.inplanes, planes, stride, dilation=1, downsample=downsample, + previous_dilation=dilation, norm_layer=norm_layer)) + elif dilation == 4: + layers.append(block(self.inplanes, planes, stride, dilation=2, downsample=downsample, + previous_dilation=dilation, norm_layer=norm_layer)) + else: + raise RuntimeError("=> unknown dilation size: {}".format(dilation)) + else: + layers.append(block(self.inplanes, planes, stride, dilation=multi_dilation[0], + downsample=downsample, previous_dilation=dilation, norm_layer=norm_layer)) + self.inplanes = planes * block.expansion + + if multi_grid: + div = len(multi_dilation) + for i in range(1, blocks): + layers.append(block(self.inplanes, planes, dilation=multi_dilation[i % div], + previous_dilation=dilation, norm_layer=norm_layer)) + else: + for _ in range(1, blocks): + layers.append(block(self.inplanes, planes, dilation=dilation, + previous_dilation=dilation, norm_layer=norm_layer)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + c1 = self.layer1(x) + c2 = self.layer2(c1) + c3 = self.layer3(c2) + c4 = self.layer4(c3) + + # for classification + # x = self.avgpool(c4) + # x = x.view(x.size(0), -1) + # x = self.fc(x) + + return c1, c2, c3, c4 + + +@BACKBONE_REGISTRY.register() +def resnet18(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [2, 2, 2, 2] + return ResNetV1(BasicBlockV1b, num_block, cfg=cfg, norm_layer=norm_layer) + + +@BACKBONE_REGISTRY.register() +def resnet34(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [3, 4, 6, 3] + return ResNetV1(BasicBlockV1b, num_block, cfg=cfg, norm_layer=norm_layer) + + +@BACKBONE_REGISTRY.register() +def resnet50(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [3, 4, 6, 3] + return ResNetV1(BottleneckV1b, num_block, cfg=cfg, norm_layer=norm_layer) + + +@BACKBONE_REGISTRY.register() +def resnet101(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [3, 4, 23, 3] + return ResNetV1(BottleneckV1b, num_block, cfg=cfg, norm_layer=norm_layer) + + +@BACKBONE_REGISTRY.register() +def resnet152(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [3, 8, 36, 3] + return ResNetV1(BottleneckV1b, num_block, cfg=cfg, norm_layer=norm_layer) + + +@BACKBONE_REGISTRY.register() +def resnet50c(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [3, 4, 6, 3] + return ResNetV1(BottleneckV1b, num_block, cfg=cfg, norm_layer=norm_layer, deep_stem=True) + + +@BACKBONE_REGISTRY.register() +def resnet101c(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [3, 4, 23, 3] + return ResNetV1(BottleneckV1b, num_block, cfg=cfg, norm_layer=norm_layer, deep_stem=True) + + +@BACKBONE_REGISTRY.register() +def resnet152c(cfg=None, norm_layer=nn.BatchNorm2d): + num_block = [3, 8, 36, 3] + return ResNetV1(BottleneckV1b, num_block, cfg=cfg, norm_layer=norm_layer, deep_stem=True) diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/xception.py b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/xception.py new file mode 100644 index 000000000..e9d0da4a2 --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/xception.py @@ -0,0 +1,297 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + +import torch.nn as nn + +from ...modules import SeparableConv2d +from .build import BACKBONE_REGISTRY + +__all__ = ['Xception65', 'Enc', 'FCAttention'] + + +class XceptionBlock(nn.Module): + def __init__(self, channel_list, stride=1, dilation=1, skip_connection_type='conv', relu_first=True, + low_feat=False, norm_layer=nn.BatchNorm2d): + super().__init__() + + assert len(channel_list) == 4 + self.skip_connection_type = skip_connection_type + self.relu_first = relu_first + self.low_feat = low_feat + + if self.skip_connection_type == 'conv': + self.conv = nn.Conv2d(channel_list[0], channel_list[-1], 1, stride=stride, bias=False) + self.bn = norm_layer(channel_list[-1]) + + self.sep_conv1 = SeparableConv2d(channel_list[0], channel_list[1], dilation=dilation, + relu_first=relu_first, norm_layer=norm_layer) + self.sep_conv2 = SeparableConv2d(channel_list[1], channel_list[2], dilation=dilation, + relu_first=relu_first, norm_layer=norm_layer) + self.sep_conv3 = SeparableConv2d(channel_list[2], channel_list[3], dilation=dilation, + relu_first=relu_first, stride=stride, norm_layer=norm_layer) + self.last_inp_channels = channel_list[3] + + def forward(self, inputs): + sc1 = self.sep_conv1(inputs) + sc2 = self.sep_conv2(sc1) + residual = self.sep_conv3(sc2) + + if self.skip_connection_type == 'conv': + shortcut = self.conv(inputs) + shortcut = self.bn(shortcut) + outputs = residual + shortcut + elif self.skip_connection_type == 'sum': + outputs = residual + inputs + elif self.skip_connection_type == 'none': + outputs = residual + else: + raise ValueError('Unsupported skip connection type.') + + if self.low_feat: + return outputs, sc2 + else: + return outputs + + +class Xception65(nn.Module): + def __init__(self, cfg=None, norm_layer=nn.BatchNorm2d): + super().__init__() + output_stride = cfg.MODEL.OUTPUT_STRIDE + if output_stride == 32: + entry_block3_stride = 2 + middle_block_dilation = 1 + exit_block_dilations = (1, 1) + exit_block_stride = 2 + elif output_stride == 16: + entry_block3_stride = 2 + middle_block_dilation = 1 + exit_block_dilations = (1, 2) + exit_block_stride = 1 + elif output_stride == 8: + entry_block3_stride = 1 + middle_block_dilation = 2 + exit_block_dilations = (2, 4) + exit_block_stride = 1 + else: + raise NotImplementedError + + # Entry flow + self.conv1 = nn.Conv2d(3, 32, 3, stride=2, padding=1, bias=False) + self.bn1 = norm_layer(32) + self.relu = nn.ReLU() + + self.conv2 = nn.Conv2d(32, 64, 3, stride=1, padding=1, bias=False) + self.bn2 = norm_layer(64) + + self.block1 = XceptionBlock([64, 128, 128, 128], stride=2, norm_layer=norm_layer) + self.block2 = XceptionBlock([128, 256, 256, 256], stride=2, low_feat=True, norm_layer=norm_layer) + self.block3 = XceptionBlock([256, 728, 728, 728], stride=entry_block3_stride, low_feat=True, + norm_layer=norm_layer) + + # Middle flow (16 units) + self.block4 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block5 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block6 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block7 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block8 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block9 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block10 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block11 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block12 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block13 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block14 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block15 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block16 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block17 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block18 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + self.block19 = XceptionBlock([728, 728, 728, 728], dilation=middle_block_dilation, + skip_connection_type='sum', norm_layer=norm_layer) + + # Exit flow + self.block20 = XceptionBlock([728, 728, 1024, 1024], stride=exit_block_stride, + dilation=exit_block_dilations[0], norm_layer=norm_layer) + self.block21 = XceptionBlock([1024, 1536, 1536, 2048], dilation=exit_block_dilations[1], + skip_connection_type='none', relu_first=False, norm_layer=norm_layer) + + def forward(self, x): + # Entry flow + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + + x = self.conv2(x) + x = self.bn2(x) + x = self.relu(x) + + x = self.block1(x) + x, c1 = self.block2(x) # b, h//4, w//4, 256 + x, c2 = self.block3(x) # b, h//8, w//8, 728 + + # Middle flow + x = self.block4(x) + x = self.block5(x) + x = self.block6(x) + x = self.block7(x) + x = self.block8(x) + x = self.block9(x) + x = self.block10(x) + x = self.block11(x) + x = self.block12(x) + x = self.block13(x) + x = self.block14(x) + x = self.block15(x) + x = self.block16(x) + x = self.block17(x) + x = self.block18(x) + c3 = self.block19(x) + + # Exit flow + x = self.block20(c3) + c4 = self.block21(x) + + return c1, c2, c3, c4 + + +# ------------------------------------------------- +# For DFANet +# ------------------------------------------------- +class BlockA(nn.Module): + def __init__(self, in_channels, out_channels, stride=1, dilation=1, norm_layer=None, start_with_relu=True): + super(BlockA, self).__init__() + if out_channels != in_channels or stride != 1: + self.skip = nn.Conv2d(in_channels, out_channels, 1, stride, bias=False) + self.skipbn = norm_layer(out_channels) + else: + self.skip = None + self.relu = nn.ReLU() + rep = list() + inter_channels = out_channels // 4 + + if start_with_relu: + rep.append(self.relu) + rep.append(SeparableConv2d(in_channels, inter_channels, 3, 1, dilation, norm_layer=norm_layer)) + rep.append(norm_layer(inter_channels)) + + rep.append(self.relu) + rep.append(SeparableConv2d(inter_channels, inter_channels, 3, 1, dilation, norm_layer=norm_layer)) + rep.append(norm_layer(inter_channels)) + + if stride != 1: + rep.append(self.relu) + rep.append(SeparableConv2d(inter_channels, out_channels, 3, stride, norm_layer=norm_layer)) + rep.append(norm_layer(out_channels)) + else: + rep.append(self.relu) + rep.append(SeparableConv2d(inter_channels, out_channels, 3, 1, norm_layer=norm_layer)) + rep.append(norm_layer(out_channels)) + self.rep = nn.Sequential(*rep) + + def forward(self, x): + out = self.rep(x) + if self.skip is not None: + skip = self.skipbn(self.skip(x)) + else: + skip = x + out = out + skip + return out + + +class Enc(nn.Module): + def __init__(self, in_channels, out_channels, blocks, norm_layer=nn.BatchNorm2d): + super(Enc, self).__init__() + block = list() + block.append(BlockA(in_channels, out_channels, 2, norm_layer=norm_layer)) + for i in range(blocks - 1): + block.append(BlockA(out_channels, out_channels, 1, norm_layer=norm_layer)) + self.block = nn.Sequential(*block) + + def forward(self, x): + return self.block(x) + + +class FCAttention(nn.Module): + def __init__(self, in_channels, norm_layer=nn.BatchNorm2d): + super(FCAttention, self).__init__() + self.avgpool = nn.AdaptiveAvgPool2d(1) + self.fc = nn.Linear(in_channels, 1000) + self.conv = nn.Sequential( + nn.Conv2d(1000, in_channels, 1, bias=False), + norm_layer(in_channels), + nn.ReLU(True)) + + def forward(self, x): + n, c, _, _ = x.size() + att = self.avgpool(x).view(n, c) + att = self.fc(att).view(n, 1000, 1, 1) + att = self.conv(att) + return x * att.expand_as(x) + + +class XceptionA(nn.Module): + def __init__(self, cfg=None, num_classes=1000, norm_layer=nn.BatchNorm2d): + super(XceptionA, self).__init__() + self.conv1 = nn.Sequential(nn.Conv2d(3, 8, 3, 2, 1, bias=False), + norm_layer(8), + nn.ReLU(True)) + + self.enc2 = Enc(8, 48, 4, norm_layer=norm_layer) + self.enc3 = Enc(48, 96, 6, norm_layer=norm_layer) + self.enc4 = Enc(96, 192, 4, norm_layer=norm_layer) + + self.fca = FCAttention(192, norm_layer=norm_layer) + self.avgpool = nn.AdaptiveAvgPool2d(1) + self.fc = nn.Linear(192, num_classes) + + def forward(self, x): + x = self.conv1(x) + + x = self.enc2(x) + x = self.enc3(x) + x = self.enc4(x) + x = self.fca(x) + + x = self.avgpool(x) + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + + +@BACKBONE_REGISTRY.register() +def xception_a(cfg=None, norm_layer=nn.BatchNorm2d): + model = XceptionA(cfg=cfg, norm_layer=norm_layer) + return model + + +@BACKBONE_REGISTRY.register() +def xception65(cfg=None, norm_layer=nn.BatchNorm2d): + model = Xception65(cfg=cfg, norm_layer=norm_layer) + return model diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/icnet.py b/cv/semantic_segmentation/icnet/pytorch/model/models/icnet.py new file mode 100644 index 000000000..5ad59c06d --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/models/icnet.py @@ -0,0 +1,114 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + +"""Image Cascade Network""" +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .segbase import SegBaseModel + +from ..modules.basic import _ConvBNReLU + + +__all__ = ['ICNet'] + + +class ICNet(SegBaseModel): + """Image Cascade Network""" + + def __init__(self, cfg): + super(ICNet, self).__init__(cfg) + self.conv_sub1 = nn.Sequential( + _ConvBNReLU(3, 32, 3, 2), + _ConvBNReLU(32, 32, 3, 2), + _ConvBNReLU(32, 64, 3, 2) + ) + + self.head = _ICHead(self.nclass, scale=cfg.MODEL.BACKBONE_SCALE) + self.__setattr__('decoder', ['conv_sub1', 'head']) + + def forward(self, x): + size = x.size()[2:] + # sub 1 + x_sub1 = self.conv_sub1(x) + + # sub 2 + x_sub2 = F.interpolate(x, scale_factor=0.5, mode='bilinear', align_corners=True) + _, x_sub2, _, _ = self.encoder(x_sub2) + + # sub 4 + x_sub4 = F.interpolate(x, scale_factor=0.25, mode='bilinear', align_corners=True) + _, _, _, x_sub4 = self.encoder(x_sub4) + + outputs = self.head(x_sub1, x_sub2, x_sub4, size) + + if self.aux: + return tuple(outputs) + else: + return outputs[0] + + +class _ICHead(nn.Module): + def __init__(self, nclass, scale=1.0, norm_layer=nn.BatchNorm2d): + super(_ICHead, self).__init__() + self.cff_12 = CascadeFeatureFusion(int(512 * scale), 64, 128, nclass, norm_layer) + self.cff_24 = CascadeFeatureFusion(int(2048 * scale), int(512 * scale), 128, nclass, norm_layer) + self.conv_cls = nn.Conv2d(128, nclass, 1, bias=False) + + def forward(self, x_sub1, x_sub2, x_sub4, size): + outputs = list() + x_cff_24, x_24_cls = self.cff_24(x_sub4, x_sub2) + outputs.append(x_24_cls) + x_cff_12, x_12_cls = self.cff_12(x_sub2, x_sub1) + outputs.append(x_12_cls) + + up_x2 = F.interpolate(x_cff_12, scale_factor=2, mode='bilinear', align_corners=True) + up_x2 = self.conv_cls(up_x2) + outputs.append(up_x2) + + up_x8 = F.interpolate(up_x2, size, mode='bilinear', align_corners=True) + outputs.append(up_x8) + # 1 -> 1/4 -> 1/8 -> 1/16 + outputs.reverse() + + return outputs + + +class CascadeFeatureFusion(nn.Module): + """CFF Unit""" + + def __init__(self, low_channels, high_channels, out_channels, nclass, norm_layer=nn.BatchNorm2d): + super(CascadeFeatureFusion, self).__init__() + self.conv_low = nn.Sequential( + nn.Conv2d(low_channels, out_channels, 3, padding=2, dilation=2, bias=False), + norm_layer(out_channels) + ) + self.conv_high = nn.Sequential( + nn.Conv2d(high_channels, out_channels, 1, bias=False), + norm_layer(out_channels) + ) + self.conv_low_cls = nn.Conv2d(out_channels, nclass, 1, bias=False) + + def forward(self, x_low, x_high): + x_low = F.interpolate(x_low, size=x_high.size()[2:], mode='bilinear', align_corners=True) + x_low = self.conv_low(x_low) + x_high = self.conv_high(x_high) + x = x_low + x_high + x = F.relu(x, inplace=True) + x_low_cls = self.conv_low_cls(x_low) + + return x, x_low_cls \ No newline at end of file diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/segbase.py b/cv/semantic_segmentation/icnet/pytorch/model/models/segbase.py new file mode 100644 index 000000000..eb1523f0a --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/models/segbase.py @@ -0,0 +1,143 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + +"""Base Model for Semantic Segmentation""" +import math +import numbers +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .backbones import get_segmentation_backbone +from ..modules import get_norm + +__all__ = ['SegBaseModel'] + + +class SegBaseModel(nn.Module): + r"""Base Model for Semantic Segmentation + """ + def __init__(self, cfg, need_backbone=True): + super(SegBaseModel, self).__init__() + self.cfg = cfg + self.nclass = cfg.MODEL.NUM_CLASS + self.aux = cfg.SOLVER.AUX + self.norm_layer = get_norm(cfg.MODEL.BN_TYPE) + self.backbone = None + self.encoder = None + if need_backbone: + self.get_backbone() + + def get_backbone(self): + self.backbone = self.cfg.MODEL.BACKBONE.lower() + self.encoder = get_segmentation_backbone(self.backbone, self.cfg, self.norm_layer) + + def base_forward(self, x): + """forwarding backbone network""" + c1, c2, c3, c4 = self.encoder(x) + return c1, c2, c3, c4 + + def demo(self, x): + pred = self.forward(x) + if self.aux: + pred = pred[0] + return pred + + def evaluate(self, image): + """evaluating network with inputs and targets""" + scales = self.cfg.TEST.SCALES + flip = self.cfg.TEST.FLIP + crop_size = _to_tuple(self.cfg.TEST.CROP_SIZE) if self.cfg.TEST.CROP_SIZE else None + batch, _, h, w = image.shape + base_size = max(h, w) + # scores = torch.zeros((batch, self.nclass, h, w)).to(image.device) + scores = None + for scale in scales: + long_size = int(math.ceil(base_size * scale)) + if h > w: + height = long_size + width = int(1.0 * w * long_size / h + 0.5) + else: + width = long_size + height = int(1.0 * h * long_size / w + 0.5) + + # resize image to current size + cur_img = _resize_image(image, height, width) + if crop_size is not None: + assert crop_size[0] >= h and crop_size[1] >= w + crop_size_scaled = (int(math.ceil(crop_size[0] * scale)), + int(math.ceil(crop_size[1] * scale))) + cur_img = _pad_image(cur_img, crop_size_scaled) + outputs = self.forward(cur_img)[0][..., :height, :width] + if flip: + outputs += _flip_image(self.forward(_flip_image(cur_img))[0])[..., :height, :width] + + score = _resize_image(outputs, h, w) + + if scores is None: + scores = score + else: + scores += score + return scores + + +def _resize_image(img, h, w): + return F.interpolate(img, size=[h, w], mode='bilinear', align_corners=True) + + +def _pad_image(img, crop_size): + b, c, h, w = img.shape + assert(c == 3) + padh = crop_size[0] - h if h < crop_size[0] else 0 + padw = crop_size[1] - w if w < crop_size[1] else 0 + if padh == 0 and padw == 0: + return img + img_pad = F.pad(img, (0, padh, 0, padw)) + + # TODO clean this code + # mean = cfg.DATASET.MEAN + # std = cfg.DATASET.STD + # pad_values = -np.array(mean) / np.array(std) + # img_pad = torch.zeros((b, c, h + padh, w + padw)).to(img.device) + # for i in range(c): + # # print(img[:, i, :, :].unsqueeze(1).shape) + # img_pad[:, i, :, :] = torch.squeeze( + # F.pad(img[:, i, :, :].unsqueeze(1), (0, padh, 0, padw), + # 'constant', value=pad_values[i]), 1) + # assert(img_pad.shape[2] >= crop_size[0] and img_pad.shape[3] >= crop_size[1]) + + return img_pad + + +def _crop_image(img, h0, h1, w0, w1): + return img[:, :, h0:h1, w0:w1] + + +def _flip_image(img): + assert(img.ndim == 4) + return img.flip((3)) + + +def _to_tuple(size): + if isinstance(size, (list, tuple)): + assert len(size), 'Expect eval crop size contains two element, ' \ + 'but received {}'.format(len(size)) + return tuple(size) + elif isinstance(size, numbers.Number): + return tuple((size, size)) + else: + raise ValueError('Unsupport datatype: {}'.format(type(size))) diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__init__.py b/cv/semantic_segmentation/icnet/pytorch/model/modules/__init__.py new file mode 100644 index 000000000..8ce1a1f99 --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/modules/__init__.py @@ -0,0 +1,5 @@ +"""Seg NN Modules""" + +from .basic import * +from .module import * +from .batch_norm import get_norm \ No newline at end of file diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/__init__.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b7f839c7b24f5e88207d7ae31c38da7c6d40812 GIT binary patch literal 297 zcmXwzO-{ow5Jv6%l&DfULluzsGaW9K;jqIFHwZ-zL{XIu^y%zuc0S~$I24qqVo&Pw z<9ZL>x@p#rP8|mbzZ9c2P4pH~br89A-ZXWYt~ggta-Pao1TE9T%!#yYMU?&g%;y;X zCcZ+=_5nawuPlHOHfqTObOvk`Q9H}Dv=G^Niq6ZP h;a@OJoOWcKYpWyYoAH#YyYuaKT0ATeMOM*@{sV7MQ)U1F literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/basic.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/basic.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51e3fc3ad5826a88edb856dc80c2644c884e0323 GIT binary patch literal 5989 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 G7XJpT)r=Yd literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/batch_norm.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/batch_norm.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1814fca1816be7f0ca2f570656e6581760e1c089 GIT binary patch literal 6668 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 t@k0q> literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/module.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/module.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d8ab976f07bd03e2675234afd3e204d56ceeac0 GIT binary patch literal 7558 zcmdT}-E$n-RqyZV>G`lcl5NRZHj~|D;~|T^c0!;`*x1&tvzzQH3SRIswa{rzw?-|^ z^o(z}WO?Wbsc2K7QYf{_LlP*88u36?s(9c9DEGY$_x4zc!A&V_IyZdL2ZgB zda6&KKKJ(R+xMRHJ0J6)R`WC*`PV=0Y`m;#|IVA);efe^GyOM^P-|8njYnFmF?#hukj9G}^g zHdUYMR8-u#{=@Z+x1%7GwtxT8=BBJ~J`+Jd4mSsbUYvBLw|W0PznG!)))&0>)?1G@ zJDl0jO z$3K0wRhD+TKa7N$Iu_TDlQ{EzX(WmC9z{>~v3GIMlg@M>EVcBdH^pE$*w3WB)f;s7 zuzOY-^|oatPW;YJkR(wrmF}GLl7Z;^z2I3SWIax@NX&a-Qf1%o^nx_?{aBktWAVbTnq9tB_$Ze(?En&sZ@=rkCx_dn>Myw?m!asBkX|Z z`^EIZSAGA>WxYV*ZDEi-}F_8X6hf7l<-KTYOiFgkhzdOJk!t0jPKDDtjrF}G?LuNP2yiz zJ+`)uutsyq%@ZAb9qlf#ZRr?yUGoTA2D2$=9-o29U0ws8g^gni(#l-wosm}O(&aN! zzJu>y!L=STs`KutSAUr z+c>38pVHf$R!JHp*b(h?mE;wYCWy2;0M#i>=z`s(v6V2UbE;J^icySUsbE?<Kl9T}#Bfi)!tPbb=3vz>&lV${*^@GJ zWmNpcJ2=zVKs1FXRbYxb4a>L=ZdJd^pV81)cxSAF*7Z?cIjrX)r-X61o9j5!pMcCD zXKZBpt^xhkcTL0)+V>6UrE(p|*4RKVi@-EC!NIM7gKke8#ldC3GAMI0ceh;FKyK&G zwoRixHpbAXiKlvytIWCToU2VaLSJb^+{MhKyA{LBMuB+0Wx^T6qexoBU|9=#aTi`; zAd*O=N>70KW*GNdb-^!_`a}8+IECQ=nijz!?F8^hZ=g+lmE<1DeGq9YaF=E$$Ud>J z;w`kdN@^noHC>P$w{cDZxc)*1H}hi-z#7&SnBvY+;vTG_p&c`L0$;jk0+L1oCGizd> zK<#{I&Xo?|$c;C(Km798$+cZ);-aOTJ10;n#5CG&2@qg5fYq zLh*nPa^+@9pv>2%CZ>XKkj@?)a5oiSW6yWkbLtb%+c38xt%EQ+s7{rkp^vVek0+lu zSDGpVKq__mZIE1_XeSKpm4U)A^)8I^@Ghf3n6I{L9&sgad}xfVF(N*?6Sy+Qclr^2 zi1MaJ&9!~<>SHY{?YeLg%1{@^C*H=(-UkwY9ar%U5)%ZU_bxAG^|8_%#Y6D{8~=cW z0jYS8g!(TwNxlUFjV2f>8&VIp?d>SYQdyd=d|`NM%@zwsJL=(7k&&h^A)s2-U(rWb zKe1>t6LLRkHjHTs-2YStL^avs`?%w-zEVDCK>T_hDJ^ngKy7nwJZ{@!oDJi#RSe@` zH62k!_tEv{<{*ukt~7%zWB3cMh{VnXgY-#!QF;J!-h`n3nr~*73hGsu&y73=9@CI6 zke24sSwCe~nK!9~22Bf3R?(-Xk^|n=l^Ho3f-q8Sx2ZgqQg2z=i-5O1pXz`5UpQvU zaH%jeeraK5Wk%`f87GA+CJ;&wald#5&`u7dyBAG4?;z;yM}@S!iS(==0kxItNP85C z0gSR6^!tG!|F^OY^!#v+(T*_=XO(!p%7-JWG zN;&ecaT%QZ{CHze_4e}eVq`p5$txU{fo5)>Sh&~VbSnt-^lKVhp?CJ^U%cj-13B7$ zmNxI66SDoVdAF$=o3zM%5jFe4Ful=y(EOmej`MAtk6Y&+6A}6)7Y&BE2E#2hTOZY)k=-v6$8>y5V$AGh#Ub)9z>-^Mnm_)*0Mg?4%hOazTqS_g6T6zORs`uorz z+HRpm=2pKiV%~-%U659Ffk(2^_qUk#sQ5x(m(ETUcXyD6K8?d{M|wjs*hQuU-IcE5 zp}W$F5P5W;$?|;i(~jzsrHPeTxamb$@Ljw-W$>!GOZrQIGx~y6XyuZDn5}U}Cug8m z`UI$wacU2B9y*62U=e%R8_^?Cy3q$GO*)lwbT|x> z&=1lAD-=xB7BC?aJ~SX1k~|?{pes@m+F08wK*3L&DpK!-0YU*dJ z+NfvO{?dhuEgvx%@eaR|RahQH@cjC?l3DmbhfehxlNMM@Ztv;hAM$EqgeBZ-yWRv+ z6-58^F_RQ;Qey=wt4}Ve^k(Vs-h9L_!7Y32lULTXHEmo2zci_4_1(*uwHuh0LO z*65Ao#_#;`xYdMlG?Uu}pY9Cydtq}cYND7M^i*;F&1jhI{QA=vqp_?z=ho_S z-M4y37Tcvg6#yeF6{sUeD(69Q0xMTIp2vL1L50Z=pB9xTItE!~-0Nc)A3!6NZB(~} zA8f0_b%1cA_{+hY)@OrGhFa3#X>$Ldi=u`~pO}3XnI`8h^}V(&{9fE|SJ=@<hE04v@t zsWi5ZyH^oZSMeLw__xRN-jQF+wN&2mZ^0nkg@=UqV!{gTUej{etx9C?W$=e67eJ15 zm8tA&tTgSy0*YP;zSSQYp|J`}Lcpt%Tm-_jnb&BEs87LHW+)oK-x?<>*BLwC;h5#n zMAi3);5<+yXt^_~z*==uwEQ)^FN0`??^PBc;3H91VA--jHkLnHHSwnu{29p)L8RG> zk|Oy%rtC)~%D;SzoKmzOlY58cV~|-r;T7<*RFnvBOQ&GOPatjExbgSeZsC`r@FExT zujrUw2Vs?I3A@0Zp(`1~f6b9;K7Y@*svOz4zSg={_#l3+bX6(s zW>Tbma(Q-pb9+DO(7y1ekGJ4esX$gbgI+IE&8e!_;twGH^QQ_gs!A(pLCR(dlSBv{ z@Sh0j6h$2M--G(IK$WUg$}I>Hg-craUd6qvX8M)F&fXwes6w5k>Z%QR-xtg!v$5Q` M-DoskYJB#;0p7EvJpcdz literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/basic.py b/cv/semantic_segmentation/icnet/pytorch/model/modules/basic.py new file mode 100644 index 000000000..32d84268d --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/modules/basic.py @@ -0,0 +1,169 @@ +"""Basic Module for Semantic Segmentation""" +import torch +import torch.nn as nn + +from collections import OrderedDict + +__all__ = ['_ConvBNPReLU', '_ConvBN', '_BNPReLU', '_ConvBNReLU', '_DepthwiseConv', 'InvertedResidual', + 'SeparableConv2d'] + +_USE_FIXED_PAD = False + + +def _pytorch_padding(kernel_size, stride=1, dilation=1, **_): + if _USE_FIXED_PAD: + return 0 # FIXME remove once verified + else: + padding = ((stride - 1) + dilation * (kernel_size - 1)) // 2 + + # FIXME remove once verified + fp = _fixed_padding(kernel_size, dilation) + assert all(padding == p for p in fp) + + return padding + + +def _fixed_padding(kernel_size, dilation): + kernel_size_effective = kernel_size + (kernel_size - 1) * (dilation - 1) + pad_total = kernel_size_effective - 1 + pad_beg = pad_total // 2 + pad_end = pad_total - pad_beg + return [pad_beg, pad_end, pad_beg, pad_end] + + +class SeparableConv2d(nn.Module): + def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, relu_first=True, + bias=False, norm_layer=nn.BatchNorm2d): + super().__init__() + depthwise = nn.Conv2d(inplanes, inplanes, kernel_size, + stride=stride, padding=dilation, + dilation=dilation, groups=inplanes, bias=bias) + bn_depth = norm_layer(inplanes) + pointwise = nn.Conv2d(inplanes, planes, 1, bias=bias) + bn_point = norm_layer(planes) + + if relu_first: + self.block = nn.Sequential(OrderedDict([('relu', nn.ReLU()), + ('depthwise', depthwise), + ('bn_depth', bn_depth), + ('pointwise', pointwise), + ('bn_point', bn_point) + ])) + else: + self.block = nn.Sequential(OrderedDict([('depthwise', depthwise), + ('bn_depth', bn_depth), + ('relu1', nn.ReLU(inplace=True)), + ('pointwise', pointwise), + ('bn_point', bn_point), + ('relu2', nn.ReLU(inplace=True)) + ])) + + def forward(self, x): + return self.block(x) + + +class _ConvBNReLU(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, + dilation=1, groups=1, relu6=False, norm_layer=nn.BatchNorm2d): + super(_ConvBNReLU, self).__init__() + self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias=False) + self.bn = norm_layer(out_channels) + self.relu = nn.ReLU6(True) if relu6 else nn.ReLU(True) + + def forward(self, x): + x = self.conv(x) + x = self.bn(x) + x = self.relu(x) + return x + + +class _ConvBNPReLU(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, + dilation=1, groups=1, norm_layer=nn.BatchNorm2d): + super(_ConvBNPReLU, self).__init__() + self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias=False) + self.bn = norm_layer(out_channels) + self.prelu = nn.PReLU(out_channels) + + def forward(self, x): + x = self.conv(x) + x = self.bn(x) + x = self.prelu(x) + return x + + +class _ConvBN(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, + dilation=1, groups=1, norm_layer=nn.BatchNorm2d, **kwargs): + super(_ConvBN, self).__init__() + self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias=False) + self.bn = norm_layer(out_channels) + + def forward(self, x): + x = self.conv(x) + x = self.bn(x) + return x + + +class _BNPReLU(nn.Module): + def __init__(self, out_channels, norm_layer=nn.BatchNorm2d): + super(_BNPReLU, self).__init__() + self.bn = norm_layer(out_channels) + self.prelu = nn.PReLU(out_channels) + + def forward(self, x): + x = self.bn(x) + x = self.prelu(x) + return x + + +# ----------------------------------------------------------------- +# For MobileNet +# ----------------------------------------------------------------- +class _DepthwiseConv(nn.Module): + """conv_dw in MobileNet""" + + def __init__(self, in_channels, out_channels, stride, norm_layer=nn.BatchNorm2d, **kwargs): + super(_DepthwiseConv, self).__init__() + self.conv = nn.Sequential( + _ConvBNReLU(in_channels, in_channels, 3, stride, 1, groups=in_channels, norm_layer=norm_layer), + _ConvBNReLU(in_channels, out_channels, 1, norm_layer=norm_layer)) + + def forward(self, x): + return self.conv(x) + + +# ----------------------------------------------------------------- +# For MobileNetV2 +# ----------------------------------------------------------------- +class InvertedResidual(nn.Module): + def __init__(self, in_channels, out_channels, stride, expand_ratio, dilation=1, norm_layer=nn.BatchNorm2d): + super(InvertedResidual, self).__init__() + assert stride in [1, 2] + self.use_res_connect = stride == 1 and in_channels == out_channels + + layers = list() + inter_channels = int(round(in_channels * expand_ratio)) + if expand_ratio != 1: + # pw + layers.append(_ConvBNReLU(in_channels, inter_channels, 1, relu6=True, norm_layer=norm_layer)) + layers.extend([ + # dw + _ConvBNReLU(inter_channels, inter_channels, 3, stride, dilation, dilation, + groups=inter_channels, relu6=True, norm_layer=norm_layer), + # pw-linear + nn.Conv2d(inter_channels, out_channels, 1, bias=False), + norm_layer(out_channels)]) + self.conv = nn.Sequential(*layers) + + def forward(self, x): + if self.use_res_connect: + return x + self.conv(x) + else: + return self.conv(x) + + +if __name__ == '__main__': + x = torch.randn(1, 32, 64, 64) + model = InvertedResidual(32, 64, 2, 1) + out = model(x) diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/batch_norm.py b/cv/semantic_segmentation/icnet/pytorch/model/modules/batch_norm.py new file mode 100644 index 000000000..590f0a7a0 --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/modules/batch_norm.py @@ -0,0 +1,183 @@ +# this code heavily based on detectron2 +import logging +import torch +import torch.distributed as dist +from torch import nn +from torch.autograd.function import Function +from ..utils.distributed import get_world_size + + +class FrozenBatchNorm2d(nn.Module): + """ + BatchNorm2d where the batch statistics and the affine parameters are fixed. + + It contains non-trainable buffers called + "weight" and "bias", "running_mean", "running_var", + initialized to perform identity transformation. + + The pre-trained backbone models from Caffe2 only contain "weight" and "bias", + which are computed from the original four parameters of BN. + The affine transform `x * weight + bias` will perform the equivalent + computation of `(x - running_mean) / sqrt(running_var) * weight + bias`. + When loading a backbone model from Caffe2, "running_mean" and "running_var" + will be left unchanged as identity transformation. + + Other pre-trained backbone models may contain all 4 parameters. + + The forward is implemented by `F.batch_norm(..., training=False)`. + """ + + _version = 3 + + def __init__(self, num_features, eps=1e-5): + super().__init__() + self.num_features = num_features + self.eps = eps + self.register_buffer("weight", torch.ones(num_features)) + self.register_buffer("bias", torch.zeros(num_features)) + self.register_buffer("running_mean", torch.zeros(num_features)) + self.register_buffer("running_var", torch.ones(num_features) - eps) + + def forward(self, x): + scale = self.weight * (self.running_var + self.eps).rsqrt() + bias = self.bias - self.running_mean * scale + scale = scale.reshape(1, -1, 1, 1) + bias = bias.reshape(1, -1, 1, 1) + return x * scale + bias + + def _load_from_state_dict( + self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs + ): + version = local_metadata.get("version", None) + + if version is None or version < 2: + # No running_mean/var in early versions + # This will silent the warnings + if prefix + "running_mean" not in state_dict: + state_dict[prefix + "running_mean"] = torch.zeros_like(self.running_mean) + if prefix + "running_var" not in state_dict: + state_dict[prefix + "running_var"] = torch.ones_like(self.running_var) + + if version is not None and version < 3: + # logger = logging.getLogger(__name__) + logging.info("FrozenBatchNorm {} is upgraded to version 3.".format(prefix.rstrip("."))) + # In version < 3, running_var are used without +eps. + state_dict[prefix + "running_var"] -= self.eps + + super()._load_from_state_dict( + state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs + ) + + def __repr__(self): + return "FrozenBatchNorm2d(num_features={}, eps={})".format(self.num_features, self.eps) + + @classmethod + def convert_frozen_batchnorm(cls, module): + """ + Convert BatchNorm/SyncBatchNorm in module into FrozenBatchNorm. + + Args: + module (torch.nn.Module): + + Returns: + If module is BatchNorm/SyncBatchNorm, returns a new module. + Otherwise, in-place convert module and return it. + + Similar to convert_sync_batchnorm in + https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/batchnorm.py + """ + bn_module = nn.modules.batchnorm + bn_module = (bn_module.BatchNorm2d, bn_module.SyncBatchNorm) + res = module + if isinstance(module, bn_module): + res = cls(module.num_features) + if module.affine: + res.weight.data = module.weight.data.clone().detach() + res.bias.data = module.bias.data.clone().detach() + res.running_mean.data = module.running_mean.data + res.running_var.data = module.running_var.data + module.eps + else: + for name, child in module.named_children(): + new_child = cls.convert_frozen_batchnorm(child) + if new_child is not child: + res.add_module(name, new_child) + return res + + +def groupNorm(num_channels, eps=1e-5, momentum=0.1, affine=True): + return nn.GroupNorm(min(32, num_channels), num_channels, eps=eps, affine=affine) + + +def get_norm(norm): + """ + Args: + norm (str or callable): + + Returns: + nn.Module or None: the normalization layer + """ + support_norm_type = ['BN', 'SyncBN', 'FrozenBN', 'GN', 'nnSyncBN'] + assert norm in support_norm_type, 'Unknown norm type {}, support norm types are {}'.format( + norm, support_norm_type) + if isinstance(norm, str): + if len(norm) == 0: + return None + norm = { + "BN": nn.BatchNorm2d, + "SyncBN": NaiveSyncBatchNorm, + "FrozenBN": FrozenBatchNorm2d, + "GN": groupNorm, + "nnSyncBN": nn.SyncBatchNorm, # keep for debugging + }[norm] + return norm + + +class AllReduce(Function): + @staticmethod + def forward(ctx, input): + input_list = [torch.zeros_like(input) for k in range(dist.get_world_size())] + # Use allgather instead of allreduce since I don't trust in-place operations .. + dist.all_gather(input_list, input, async_op=False) + inputs = torch.stack(input_list, dim=0) + return torch.sum(inputs, dim=0) + + @staticmethod + def backward(ctx, grad_output): + dist.all_reduce(grad_output, async_op=False) + return grad_output + + +class NaiveSyncBatchNorm(nn.BatchNorm2d): + """ + `torch.nn.SyncBatchNorm` has known unknown bugs. + It produces significantly worse AP (and sometimes goes NaN) + when the batch size on each worker is quite different + (e.g., when scale augmentation is used, or when it is applied to mask head). + + Use this implementation before `nn.SyncBatchNorm` is fixed. + It is slower than `nn.SyncBatchNorm`. + """ + + def forward(self, input): + if get_world_size() == 1 or not self.training: + return super().forward(input) + + assert input.shape[0] > 0, "SyncBatchNorm does not support empty inputs" + C = input.shape[1] + mean = torch.mean(input, dim=[0, 2, 3]) + meansqr = torch.mean(input * input, dim=[0, 2, 3]) + + vec = torch.cat([mean, meansqr], dim=0) + vec = AllReduce.apply(vec) * (1.0 / dist.get_world_size()) + + mean, meansqr = torch.split(vec, C) + var = meansqr - mean * mean + self.running_mean += self.momentum * (mean.detach() - self.running_mean) + self.running_var += self.momentum * (var.detach() - self.running_var) + + invstd = torch.rsqrt(var + self.eps) + scale = self.weight * invstd + bias = self.bias - mean * scale + scale = scale.reshape(1, -1, 1, 1) + bias = bias.reshape(1, -1, 1, 1) + return input * scale + bias diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/module.py b/cv/semantic_segmentation/icnet/pytorch/model/modules/module.py new file mode 100644 index 000000000..2a0cea95b --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/modules/module.py @@ -0,0 +1,223 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + + +"""Basic Module for Semantic Segmentation""" +import torch +import torch.nn as nn +import torch.nn.functional as F + +from collections import OrderedDict +from .basic import _ConvBNReLU, SeparableConv2d, _ConvBN, _BNPReLU, _ConvBNPReLU + + +__all__ = ['_FCNHead', '_ASPP', 'PyramidPooling', 'PAM_Module', 'CAM_Module', 'EESP'] + + +class _FCNHead(nn.Module): + def __init__(self, in_channels, channels, norm_layer=nn.BatchNorm2d): + super(_FCNHead, self).__init__() + inter_channels = in_channels // 4 + self.block = nn.Sequential( + nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False), + norm_layer(inter_channels), + nn.ReLU(inplace=True), + nn.Dropout(0.1), + nn.Conv2d(inter_channels, channels, 1) + ) + + def forward(self, x): + return self.block(x) + + +# ----------------------------------------------------------------- +# For deeplab +# ----------------------------------------------------------------- +class _ASPP(nn.Module): + def __init__(self, output_stride, in_channels=2048, out_channels=256): + super().__init__() + if output_stride == 16: + dilations = [6, 12, 18] + elif output_stride == 8: + dilations = [12, 24, 36] + elif output_stride == 32: + dilations = [6, 12, 18] + else: + raise NotImplementedError + + self.aspp0 = nn.Sequential(OrderedDict([('conv', nn.Conv2d(in_channels, out_channels, 1, bias=False)), + ('bn', nn.BatchNorm2d(out_channels)), + ('relu', nn.ReLU(inplace=True))])) + self.aspp1 = SeparableConv2d(in_channels, out_channels, dilation=dilations[0], relu_first=False) + self.aspp2 = SeparableConv2d(in_channels, out_channels, dilation=dilations[1], relu_first=False) + self.aspp3 = SeparableConv2d(in_channels, out_channels, dilation=dilations[2], relu_first=False) + + self.image_pooling = nn.Sequential(OrderedDict([('gap', nn.AdaptiveAvgPool2d((1, 1))), + ('conv', nn.Conv2d(in_channels, out_channels, 1, bias=False)), + ('bn', nn.BatchNorm2d(out_channels)), + ('relu', nn.ReLU(inplace=True))])) + + self.conv = nn.Conv2d(out_channels*5, out_channels, 1, bias=False) + self.bn = nn.BatchNorm2d(out_channels) + self.relu = nn.ReLU(inplace=True) + self.dropout = nn.Dropout2d(p=0.1) + + def forward(self, x): + pool = self.image_pooling(x) + pool = F.interpolate(pool, size=x.shape[2:], mode='bilinear', align_corners=True) + + x0 = self.aspp0(x) + x1 = self.aspp1(x) + x2 = self.aspp2(x) + x3 = self.aspp3(x) + x = torch.cat((pool, x0, x1, x2, x3), dim=1) + + x = self.conv(x) + x = self.bn(x) + x = self.relu(x) + x = self.dropout(x) + + return x + +# ----------------------------------------------------------------- +# For PSPNet, fast_scnn +# ----------------------------------------------------------------- +class PyramidPooling(nn.Module): + def __init__(self, in_channels, sizes=(1, 2, 3, 6), norm_layer=nn.BatchNorm2d, **kwargs): + super(PyramidPooling, self).__init__() + out_channels = int(in_channels / 4) + self.avgpools = nn.ModuleList() + self.convs = nn.ModuleList() + for size in sizes: + self.avgpools.append(nn.AdaptiveAvgPool2d(size)) + self.convs.append(_ConvBNReLU(in_channels, out_channels, 1, norm_layer=norm_layer, **kwargs)) + + def forward(self, x): + size = x.size()[2:] + feats = [x] + for (avgpool, conv) in zip(self.avgpools, self.convs): + feats.append(F.interpolate(conv(avgpool(x)), size, mode='bilinear', align_corners=True)) + return torch.cat(feats, dim=1) + + +class PAM_Module(nn.Module): + """ Position attention module""" + def __init__(self, in_dim): + super(PAM_Module, self).__init__() + self.chanel_in = in_dim + + self.query_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1) + self.key_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1) + self.value_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1) + self.gamma = nn.Parameter(torch.zeros(1)) + self.softmax = nn.Softmax(dim=-1) + + def forward(self, x): + """ + inputs : + x : input feature maps( B X C X H X W) + returns : + out : attention value + input feature + attention: B X (HxW) X (HxW) + """ + m_batchsize, C, height, width = x.size() + proj_query = self.query_conv(x).view(m_batchsize, -1, width*height).permute(0, 2, 1) + proj_key = self.key_conv(x).view(m_batchsize, -1, width*height) + energy = torch.bmm(proj_query, proj_key) + attention = self.softmax(energy) + proj_value = self.value_conv(x).view(m_batchsize, -1, width*height) + + out = torch.bmm(proj_value, attention.permute(0, 2, 1)) + out = out.view(m_batchsize, C, height, width) + + out = self.gamma*out + x + return out + + +class CAM_Module(nn.Module): + """ Channel attention module""" + def __init__(self, in_dim): + super(CAM_Module, self).__init__() + self.chanel_in = in_dim + self.gamma = nn.Parameter(torch.zeros(1)) + self.softmax = nn.Softmax(dim=-1) + + def forward(self,x): + """ + inputs : + x : input feature maps( B X C X H X W) + returns : + out : attention value + input feature + attention: B X C X C + """ + m_batchsize, C, height, width = x.size() + proj_query = x.view(m_batchsize, C, -1) + proj_key = x.view(m_batchsize, C, -1).permute(0, 2, 1) + energy = torch.bmm(proj_query, proj_key) + energy_new = torch.max(energy, -1, keepdim=True)[0].expand_as(energy)-energy + attention = self.softmax(energy_new) + proj_value = x.view(m_batchsize, C, -1) + + out = torch.bmm(attention, proj_value) + out = out.view(m_batchsize, C, height, width) + + out = self.gamma*out + x + return out + + +class EESP(nn.Module): + + def __init__(self, in_channels, out_channels, stride=1, k=4, r_lim=7, down_method='esp', norm_layer=nn.BatchNorm2d): + super(EESP, self).__init__() + self.stride = stride + n = int(out_channels / k) + n1 = out_channels - (k - 1) * n + assert down_method in ['avg', 'esp'], 'One of these is suppported (avg or esp)' + assert n == n1, "n(={}) and n1(={}) should be equal for Depth-wise Convolution ".format(n, n1) + self.proj_1x1 = _ConvBNPReLU(in_channels, n, 1, stride=1, groups=k, norm_layer=norm_layer) + + map_receptive_ksize = {3: 1, 5: 2, 7: 3, 9: 4, 11: 5, 13: 6, 15: 7, 17: 8} + self.k_sizes = list() + for i in range(k): + ksize = int(3 + 2 * i) + ksize = ksize if ksize <= r_lim else 3 + self.k_sizes.append(ksize) + self.k_sizes.sort() + self.spp_dw = nn.ModuleList() + for i in range(k): + dilation = map_receptive_ksize[self.k_sizes[i]] + self.spp_dw.append(nn.Conv2d(n, n, 3, stride, dilation, dilation=dilation, groups=n, bias=False)) + self.conv_1x1_exp = _ConvBN(out_channels, out_channels, 1, 1, groups=k, norm_layer=norm_layer) + self.br_after_cat = _BNPReLU(out_channels, norm_layer) + self.module_act = nn.PReLU(out_channels) + self.downAvg = True if down_method == 'avg' else False + + def forward(self, x): + output1 = self.proj_1x1(x) + output = [self.spp_dw[0](output1)] + for k in range(1, len(self.spp_dw)): + out_k = self.spp_dw[k](output1) + out_k = out_k + output[k - 1] + output.append(out_k) + expanded = self.conv_1x1_exp(self.br_after_cat(torch.cat(output, 1))) + del output + if self.stride == 2 and self.downAvg: + return expanded + + if expanded.size() == x.size(): + expanded = expanded + x + + return self.module_act(expanded) \ No newline at end of file diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/sync_bn/syncbn.py b/cv/semantic_segmentation/icnet/pytorch/model/modules/sync_bn/syncbn.py new file mode 100644 index 000000000..f1247af97 --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/modules/sync_bn/syncbn.py @@ -0,0 +1,124 @@ +##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +## Created by: Hang Zhang +## ECE Department, Rutgers University +## Email: zhang.hang@rutgers.edu +## Copyright (c) 2017 +## +## This source code is licensed under the MIT-style license found in the +## LICENSE file in the root directory of this source tree +##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +"""Synchronized Cross-GPU Batch Normalization Module""" +import warnings +import torch + +from torch.nn.modules.batchnorm import _BatchNorm +from queue import Queue +from .functions import * + +__all__ = ['SyncBatchNorm', 'BatchNorm1d', 'BatchNorm2d', 'BatchNorm3d'] + + +# Adopt from https://github.com/zhanghang1989/PyTorch-Encoding/blob/master/encoding/nn/syncbn.py +class SyncBatchNorm(_BatchNorm): + """Cross-GPU Synchronized Batch normalization (SyncBN) + + Parameters: + num_features: num_features from an expected input of + size batch_size x num_features x height x width + eps: a value added to the denominator for numerical stability. + Default: 1e-5 + momentum: the value used for the running_mean and running_var + computation. Default: 0.1 + sync: a boolean value that when set to ``True``, synchronize across + different gpus. Default: ``True`` + activation : str + Name of the activation functions, one of: `leaky_relu` or `none`. + slope : float + Negative slope for the `leaky_relu` activation. + + Shape: + - Input: :math:`(N, C, H, W)` + - Output: :math:`(N, C, H, W)` (same shape as input) + Reference: + .. [1] Ioffe, Sergey, and Christian Szegedy. "Batch normalization: Accelerating deep network training by reducing internal covariate shift." *ICML 2015* + .. [2] Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, and Amit Agrawal. "Context Encoding for Semantic Segmentation." *CVPR 2018* + Examples: + >>> m = SyncBatchNorm(100) + >>> net = torch.nn.DataParallel(m) + >>> output = net(input) + """ + + def __init__(self, num_features, eps=1e-5, momentum=0.1, sync=True, activation='none', slope=0.01, inplace=True): + super(SyncBatchNorm, self).__init__(num_features, eps=eps, momentum=momentum, affine=True) + self.activation = activation + self.inplace = False if activation == 'none' else inplace + self.slope = slope + self.devices = list(range(torch.cuda.device_count())) + self.sync = sync if len(self.devices) > 1 else False + # Initialize queues + self.worker_ids = self.devices[1:] + self.master_queue = Queue(len(self.worker_ids)) + self.worker_queues = [Queue(1) for _ in self.worker_ids] + + def forward(self, x): + # resize the input to (B, C, -1) + input_shape = x.size() + x = x.view(input_shape[0], self.num_features, -1) + if x.get_device() == self.devices[0]: + # Master mode + extra = { + "is_master": True, + "master_queue": self.master_queue, + "worker_queues": self.worker_queues, + "worker_ids": self.worker_ids + } + else: + # Worker mode + extra = { + "is_master": False, + "master_queue": self.master_queue, + "worker_queue": self.worker_queues[self.worker_ids.index(x.get_device())] + } + if self.inplace: + return inp_syncbatchnorm(x, self.weight, self.bias, self.running_mean, self.running_var, + extra, self.sync, self.training, self.momentum, self.eps, + self.activation, self.slope).view(input_shape) + else: + return syncbatchnorm(x, self.weight, self.bias, self.running_mean, self.running_var, + extra, self.sync, self.training, self.momentum, self.eps, + self.activation, self.slope).view(input_shape) + + def extra_repr(self): + if self.activation == 'none': + return 'sync={}'.format(self.sync) + else: + return 'sync={}, act={}, slope={}, inplace={}'.format( + self.sync, self.activation, self.slope, self.inplace) + + +class BatchNorm1d(SyncBatchNorm): + """BatchNorm1d is deprecated in favor of :class:`core.nn.sync_bn.SyncBatchNorm`.""" + + def __init__(self, *args, **kwargs): + warnings.warn("core.nn.sync_bn.{} is now deprecated in favor of core.nn.sync_bn.{}." + .format('BatchNorm1d', SyncBatchNorm.__name__), DeprecationWarning) + super(BatchNorm1d, self).__init__(*args, **kwargs) + + +class BatchNorm2d(SyncBatchNorm): + """BatchNorm1d is deprecated in favor of :class:`core.nn.sync_bn.SyncBatchNorm`.""" + + def __init__(self, *args, **kwargs): + warnings.warn("core.nn.sync_bn.{} is now deprecated in favor of core.nn.sync_bn.{}." + .format('BatchNorm2d', SyncBatchNorm.__name__), DeprecationWarning) + super(BatchNorm2d, self).__init__(*args, **kwargs) + + +class BatchNorm3d(SyncBatchNorm): + """BatchNorm1d is deprecated in favor of :class:`core.nn.sync_bn.SyncBatchNorm`.""" + + def __init__(self, *args, **kwargs): + warnings.warn("core.nn.sync_bn.{} is now deprecated in favor of core.nn.sync_bn.{}." + .format('BatchNorm3d', SyncBatchNorm.__name__), DeprecationWarning) + super(BatchNorm3d, self).__init__(*args, **kwargs) diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/__init__.py b/cv/semantic_segmentation/icnet/pytorch/model/utils/__init__.py new file mode 100644 index 000000000..2e4bb41ab --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/utils/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/__init__.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9cea4db19f3cb0a715e6bd7a159b2869f606be14 GIT binary patch literal 181 zcmZ?b<>g`kf*P+0$!C}t7#@Q-Fu(|8H~?`m3y?@*2xib^^jpbL1QJFNzvA>W@^e%5 zD>4&-RHj~eVqUs_N@{9BaY15Hc1CHEesY<9acXX2UP)$hd~s@eZfaghVo7Fxo_=O> zUTTScL1jsPQF4ZUZhlH?j(%xLW=^qwe0*kJW=VX!UP0w84jZ6MX-=vg$llLD%m4u4 CPBLo% literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/distributed.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/distributed.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5435a72926adbf52a7cd570664fef23d908b0b3 GIT binary patch literal 7644 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 literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/registry.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/registry.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b88c49b4efc6d33a62acba9712d14e9344ce68b5 GIT binary patch literal 2260 zcma)7TW{k;6rQo2#O;XnA5C;kFYoHLG{7FB3RnHgs;=k|T)%>K&CGJ!Vx=C|l;`1%X~ zl+A&UUFiA?7&zfHA)R8T9ePN(#qBG?ZDC#79h=i*;yHiANz#sRESn7Ex3civIc zZYiu%<(INHJmVVL6D6V6?AytH7!6KkDmK6oTrZpN&*Sh)y`$d$QM*u67!X-N3v4)J zKY*^+V3^Sv2}n#}q=sGA^hIUYp6cnlRvNrFfF9l!04oaoWfwu#6>8P}wrAzF0Po~( z02B#;AF$+Tk#uth*Z&}@0apC;eXB2rqV;1O!W8>&!?f4pLX0%wxaWv7Q-;j z;wYGtApqofNfe(z-85uP6;|wBoZJGb}jde+XrZWroW^@}e7qZA|PoM3TEHW|T zZ2hN;b@n#YEKGpqd@_%gP=d2KEw)RGKldDkHs-5)8Zrj`e6EyKdA%#uFw7Jh=h+JF zQ*}IOLv&3fi^0XUX24}oG7;;7#-qe)(lt8$aN+r_Q|-!qRF54snW8cSrw6WjJhQs= z7t*Dsuq<8JGy9m#pwz(LlNmiD7uK)j8UsRaEDGfe3)b}aiV}rd$TDP4FFqGln8qoe zFIU8R16~0#NR%LW<5xlsAVp6FRuj%3q9TSHkhhGBNU9K+z~Gn4%xA|!FfJn?ER-cy z61B)hh$V;!dtxEDeJ4@S{}0grPhkN63HZ2*KwnVfBM<_8oFU{CxehEVY*j08!?QXo z-EkTPQUyk%fy$!=Y)E@$aB|S>L)3$R33X|mHtF=U3ZW81e;aCDnCKlJZ+MnkMHxnw zQwVM10-~(m!vS@a`iv^K6txRG8c&m&YpvBC8;K%WP+2_b#onl`I|g4_rmH`8!N=MJE23}^;`o?+Huzy2CIyA^MgaL61%X-u zVFqP|1=~2MKEkhs_R0i>Naz;!=%EO*JRFF$e{X2)~#Mk0GXNQS&-DrR0Uo^G>! UpTykVE)3jxgkmuUE_LmH0g@XkKmY&$ literal 0 HcmV?d00001 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/distributed.py b/cv/semantic_segmentation/icnet/pytorch/model/utils/distributed.py new file mode 100644 index 000000000..8c681a1cf --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/utils/distributed.py @@ -0,0 +1,251 @@ +""" +code is heavily based on https://github.com/facebookresearch/maskrcnn-benchmark +""" +import math +import pickle +import torch +import torch.utils.data as data +import torch.distributed as dist + +from torch.utils.data.sampler import Sampler, BatchSampler + +__all__ = ['get_world_size', 'get_rank', 'synchronize', 'is_main_process', + 'all_gather', 'make_data_sampler', 'make_batch_data_sampler', + 'reduce_dict', 'reduce_loss_dict'] + + +def get_world_size(): + if not dist.is_available(): + return 1 + if not dist.is_initialized(): + return 1 + return dist.get_world_size() + + +def get_rank(): + if not dist.is_available(): + return 0 + if not dist.is_initialized(): + return 0 + return dist.get_rank() + + +def is_main_process(): + return get_rank() == 0 + + +def synchronize(): + """ + Helper function to synchronize (barrier) among all processes when + using distributed training + """ + if not dist.is_available(): + return + if not dist.is_initialized(): + return + world_size = dist.get_world_size() + if world_size == 1: + return + dist.barrier() + + +def all_gather(data): + """ + Run all_gather on arbitrary picklable data (not necessarily tensors) + Args: + data: any picklable object + Returns: + list[data]: list of data gathered from each rank + """ + world_size = get_world_size() + if world_size == 1: + return [data] + + # serialized to a Tensor + buffer = pickle.dumps(data) + storage = torch.ByteStorage.from_buffer(buffer) + tensor = torch.ByteTensor(storage).to("cuda") + + # obtain Tensor size of each rank + local_size = torch.IntTensor([tensor.numel()]).to("cuda") + size_list = [torch.IntTensor([0]).to("cuda") for _ in range(world_size)] + dist.all_gather(size_list, local_size) + size_list = [int(size.item()) for size in size_list] + max_size = max(size_list) + + # receiving Tensor from all ranks + # we pad the tensor because torch all_gather does not support + # gathering tensors of different shapes + tensor_list = [] + for _ in size_list: + tensor_list.append(torch.ByteTensor(size=(max_size,)).to("cuda")) + if local_size != max_size: + padding = torch.ByteTensor(size=(max_size - local_size,)).to("cuda") + tensor = torch.cat((tensor, padding), dim=0) + dist.all_gather(tensor_list, tensor) + + data_list = [] + for size, tensor in zip(size_list, tensor_list): + buffer = tensor.cpu().numpy().tobytes()[:size] + data_list.append(pickle.loads(buffer)) + + return data_list + + +def reduce_dict(input_dict, average=True): + """ + Args: + input_dict (dict): all the values will be reduced + average (bool): whether to do average or sum + Reduce the values in the dictionary from all processes so that process with rank + 0 has the averaged results. Returns a dict with the same fields as + input_dict, after reduction. + """ + world_size = get_world_size() + if world_size < 2: + return input_dict + with torch.no_grad(): + names = [] + values = [] + # sort the keys so that they are consistent across processes + for k in sorted(input_dict.keys()): + names.append(k) + values.append(input_dict[k]) + values = torch.stack(values, dim=0) + dist.reduce(values, dst=0) + if dist.get_rank() == 0 and average: + # only main process gets accumulated, so only divide by + # world_size in this case + values /= world_size + reduced_dict = {k: v for k, v in zip(names, values)} + return reduced_dict + + +def reduce_loss_dict(loss_dict): + """ + Reduce the loss dictionary from all processes so that process with rank + 0 has the averaged results. Returns a dict with the same fields as + loss_dict, after reduction. + """ + world_size = get_world_size() + if world_size < 2: + return loss_dict + with torch.no_grad(): + loss_names = [] + all_losses = [] + for k in sorted(loss_dict.keys()): + loss_names.append(k) + all_losses.append(loss_dict[k]) + all_losses = torch.stack(all_losses, dim=0) + dist.reduce(all_losses, dst=0) + if dist.get_rank() == 0: + # only main process gets accumulated, so only divide by + # world_size in this case + all_losses /= world_size + reduced_losses = {k: v for k, v in zip(loss_names, all_losses)} + return reduced_losses + + +def make_data_sampler(dataset, shuffle, distributed): + if distributed: + return DistributedSampler(dataset, shuffle=shuffle) + if shuffle: + sampler = data.sampler.RandomSampler(dataset) + else: + sampler = data.sampler.SequentialSampler(dataset) + return sampler + + +def make_batch_data_sampler(sampler, images_per_batch, num_iters=None, start_iter=0, drop_last=True): + batch_sampler = data.sampler.BatchSampler(sampler, images_per_batch, drop_last=drop_last) + if num_iters is not None: + batch_sampler = IterationBasedBatchSampler(batch_sampler, num_iters, start_iter) + return batch_sampler + + +class DistributedSampler(Sampler): + """Sampler that restricts data loading to a subset of the dataset. + It is especially useful in conjunction with + :class:`torch.nn.parallel.DistributedDataParallel`. In such case, each + process can pass a DistributedSampler instance as a DataLoader sampler, + and load a subset of the original dataset that is exclusive to it. + .. note:: + Dataset is assumed to be of constant size. + Arguments: + dataset: Dataset used for sampling. + num_replicas (optional): Number of processes participating in + distributed training. + rank (optional): Rank of the current process within num_replicas. + """ + + def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True): + if num_replicas is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + num_replicas = dist.get_world_size() + if rank is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + rank = dist.get_rank() + self.dataset = dataset + self.num_replicas = num_replicas + self.rank = rank + self.epoch = 0 + self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / self.num_replicas)) + self.total_size = self.num_samples * self.num_replicas + self.shuffle = shuffle + + def __iter__(self): + if self.shuffle: + # deterministically shuffle based on epoch + g = torch.Generator() + g.manual_seed(self.epoch) + indices = torch.randperm(len(self.dataset), generator=g).tolist() + else: + indices = torch.arange(len(self.dataset)).tolist() + + # add extra samples to make it evenly divisible + indices += indices[: (self.total_size - len(indices))] + assert len(indices) == self.total_size + + # subsample + offset = self.num_samples * self.rank + indices = indices[offset: offset + self.num_samples] + assert len(indices) == self.num_samples + + return iter(indices) + + def __len__(self): + return self.num_samples + + def set_epoch(self, epoch): + self.epoch = epoch + + +class IterationBasedBatchSampler(BatchSampler): + """ + Wraps a BatchSampler, resampling from it until + a specified number of iterations have been sampled + """ + + def __init__(self, batch_sampler, num_iterations, start_iter=0): + self.batch_sampler = batch_sampler + self.num_iterations = num_iterations + self.start_iter = start_iter + + def __iter__(self): + iteration = self.start_iter + while iteration <= self.num_iterations: + # if the underlying sampler has a set_epoch method, like + # DistributedSampler, used for making each process see + # a different split of the dataset, then set it + if hasattr(self.batch_sampler.sampler, "set_epoch"): + self.batch_sampler.sampler.set_epoch(iteration) + for batch in self.batch_sampler: + iteration += 1 + if iteration > self.num_iterations: + break + yield batch + + def __len__(self): + return self.num_iterations diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/registry.py b/cv/semantic_segmentation/icnet/pytorch/model/utils/registry.py new file mode 100644 index 000000000..d564bd2cd --- /dev/null +++ b/cv/semantic_segmentation/icnet/pytorch/model/utils/registry.py @@ -0,0 +1,92 @@ +# Copyright (c) 2022, Shanghai Iluvatar CoreX Semiconductor Co., Ltd. +# All Rights Reserved. +# Copyright (c) SegmenTron. All Rights Reserved. +# +# 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. + + +# this code heavily based on detectron2 + +import logging +import torch + + +class Registry(object): + """ + The registry that provides name -> object mapping, to support third-party users' custom modules. + + To create a registry (inside segmentron): + + .. code-block:: python + + BACKBONE_REGISTRY = Registry('BACKBONE') + + To register an object: + + .. code-block:: python + + @BACKBONE_REGISTRY.register() + class MyBackbone(): + ... + + Or: + + .. code-block:: python + + BACKBONE_REGISTRY.register(MyBackbone) + """ + + def __init__(self, name): + """ + Args: + name (str): the name of this registry + """ + self._name = name + + self._obj_map = {} + + def _do_register(self, name, obj): + assert ( + name not in self._obj_map + ), "An object named '{}' was already registered in '{}' registry!".format(name, self._name) + self._obj_map[name] = obj + + def register(self, obj=None, name=None): + """ + Register the given object under the the name `obj.__name__`. + Can be used as either a decorator or not. See docstring of this class for usage. + """ + if obj is None: + # used as a decorator + def deco(func_or_class, name=name): + if name is None: + name = func_or_class.__name__ + self._do_register(name, func_or_class) + return func_or_class + + return deco + + # used as a function call + if name is None: + name = obj.__name__ + self._do_register(name, obj) + + def get(self, name): + ret = self._obj_map.get(name) + if ret is None: + raise KeyError("No object named '{}' found in '{}' registry!".format(name, self._name)) + + return ret + + def get_list(self): + return list(self._obj_map.keys()) -- Gitee From fe26574595091eb4bbdd23c1011ac92a3e9b56d2 Mon Sep 17 00:00:00 2001 From: root Date: Wed, 7 Dec 2022 08:34:33 +0000 Subject: [PATCH 2/2] FIX ICNET --- .../model/__pycache__/__init__.cpython-37.pyc | Bin 339 -> 0 bytes .../model/__pycache__/builder.cpython-37.pyc | Bin 2695 -> 0 bytes .../models/__pycache__/__init__.cpython-37.pyc | Bin 230 -> 0 bytes .../models/__pycache__/icnet.cpython-37.pyc | Bin 3329 -> 0 bytes .../models/__pycache__/segbase.cpython-37.pyc | Bin 3750 -> 0 bytes .../__pycache__/__init__.cpython-37.pyc | Bin 375 -> 0 bytes .../backbones/__pycache__/build.cpython-37.pyc | Bin 1897 -> 0 bytes .../__pycache__/eespnet.cpython-37.pyc | Bin 4680 -> 0 bytes .../backbones/__pycache__/hrnet.cpython-37.pyc | Bin 11720 -> 0 bytes .../__pycache__/mobilenet.cpython-37.pyc | Bin 4262 -> 0 bytes .../backbones/__pycache__/resnet.cpython-37.pyc | Bin 6599 -> 0 bytes .../__pycache__/xception.cpython-37.pyc | Bin 7599 -> 0 bytes .../modules/__pycache__/__init__.cpython-37.pyc | Bin 297 -> 0 bytes .../modules/__pycache__/basic.cpython-37.pyc | Bin 5989 -> 0 bytes .../__pycache__/batch_norm.cpython-37.pyc | Bin 6668 -> 0 bytes .../modules/__pycache__/module.cpython-37.pyc | Bin 7558 -> 0 bytes .../utils/__pycache__/__init__.cpython-37.pyc | Bin 181 -> 0 bytes .../__pycache__/distributed.cpython-37.pyc | Bin 7644 -> 0 bytes .../utils/__pycache__/registry.cpython-37.pyc | Bin 2260 -> 0 bytes 19 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/__pycache__/__init__.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/__pycache__/builder.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/__init__.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/icnet.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/segbase.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/__init__.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/build.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/eespnet.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/hrnet.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/mobilenet.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/resnet.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/xception.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/__init__.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/basic.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/batch_norm.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/module.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/__init__.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/distributed.cpython-37.pyc delete mode 100644 cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/registry.cpython-37.pyc diff --git a/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/__init__.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/__init__.cpython-37.pyc deleted file mode 100644 index c91f0abc7c32afb5fd0b3bfc6c49646400effe3f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 339 zcmYjLO-jTt82ysgsT4-gm3V`0CLUlAQCBY9xDi1@CJk+9n${-cSg5P<0D6O&rB}+< zBeJ!HngU|D{g6iy!1vhv0eiSax>J-Ka`Fxe*03R4xPdi!q&dBZ zERqD*BPj9!d5v^uC2r)t4Rm%MNc9EX z=(2lYWm7Bmss$E3TM1jRT&dQzqN~c~g2@-=R4uI6k~>w@%6j2-W0{s#dDiy6>14_3 zCRc`WuC4Z*&)R;M&W(0nHg$V(JZ2q(PoPV%++|Tn3ezlvaUrf$??S@4FoyGes(&)U Q^Kdvv`=wEPqaU2WFKp6Q4gdfE diff --git a/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/builder.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/__pycache__/builder.cpython-37.pyc deleted file mode 100644 index 395b7c070d27e5eccba5a31220ce1115b3d97a23..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2695 zcmZuz&2!tv72gFw5~3tpmKE7f-GoV%CP-7!k<*)N8zff}BM{^epjGcQv!S>!O`9Jw z0QzgFPFwlV3p?pC>2$_9_Mhmz{{l{($w{}KbLx8w>LZ>mX5a4nz`lLIefxm&@^YR) zn|}FC_g|}o{D919`w%AgphxdgLL`xNKztI=fJ#m3GaL>gD@Az=H@{NxG{-!iz__L#7}W|J3~YnL4+s;ttevKC)Oso1aiyTW5lQE9mM`Py75 z@U2s6VjOg$0KDZI6=An3yS?we#rE&Jmd=+hHDGLZ;lZ-O4U-dBvgYxu&vfyDoD)o>3d(i`y7- zo%y?s>WOk?pqC8zuT@U|2=fyH&|4k=`8-qE!C|4a5pr?z2{sQE_wuyR(Mbdk=ba4M;#Z+(51c`eTD2869@QCyyovrS7v*6bw6~xZed&y-sgiUN5Nvo=P*Z^( zwSdHAN@9Afh1Vn$!Pmf5$uWSV)=Kzd;I)zT4#<>@i~oA%W3QbeHEn27Aw_~0=djJA0* zp)bw>3*U#Af6U(=^rN^t9v5H4U2jgyM5Z!^vsiBog^8KhkisH_w z8zcrQ!t3y&0wyfN%+eDb+$M(TKI|p*$y;uf%>?WsEO~_HX#si``WiJfrS0NQuwk$n z=nCIIz+_6_kna({!zp<~zefz^@3kZCNRPFt4%lkZ=2V{}xjNOR^hqwfcP;@dK>0dR zmNGUZjWd5IQu~KK)z;w*{!E{)#@W;!&O}+mnXIN~0%!56@L)VC4kuAugp4hI{c7X4 zemDufF2>{HL&%|^*clba&w}uI2jq+z8{uA_Q z9SET&T?K^mFe2VdG_S4G5N&>vT$s-aYh3g!mp5YVjgF|RT!rjDB5`I4XdS66wWw=l zFN9R^*bdgPR>KvQ?VZqqwUnzgJD}2ZRhi%>exWc)-r9R|Ro%eTiyDqcB7Nf+p2Lp=!0>sqNRaQ~$yru3_DeCpK nD_fYKON^gb8Wef7RyJ_y&p8a^oWoSr=vrg`kf*P+0$%mO37#@Q-FaYE;H~?|60FX#wh+;@#Okv7l3}HxN4rb6~sp9m_ zPf5*Dh|14@$p}=T$#{!V%TJT(7JGbrN`7*Dd=zVDa$ai5N`@j9pfs5H6|bL>pPQ;* zk(mgjGWE(6^V0QGQd0|x3lfX6GfI>6lgsprQ*#sZN-~qN!AD diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/icnet.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/__pycache__/icnet.cpython-37.pyc deleted file mode 100644 index 6f2cfe75374fd357e84e677b8aa5c3cecbae7a53..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3329 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 It`HLb7jHg=tpET3 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/__init__.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/__init__.cpython-37.pyc deleted file mode 100644 index 0ebaf000172bfa4d351758684e7abeda95b0bf21..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 375 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 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/hrnet.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/hrnet.cpython-37.pyc deleted file mode 100644 index c397e29c766a995da6508ab22fc763c1749a0753..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11720 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 NzcBs_#Jp~@{{Y9)(=z}7 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/resnet.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/resnet.cpython-37.pyc deleted file mode 100644 index 91dcaba7e366127e63bda1640ea84b6e47640aec..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6599 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 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/xception.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/models/backbones/__pycache__/xception.cpython-37.pyc deleted file mode 100644 index 84eafb57b1a0c3a7d4e911189fe885c03c2fb612..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7599 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 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/basic.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/basic.cpython-37.pyc deleted file mode 100644 index 51e3fc3ad5826a88edb856dc80c2644c884e0323..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5989 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 G7XJpT)r=Yd diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/batch_norm.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/batch_norm.cpython-37.pyc deleted file mode 100644 index 1814fca1816be7f0ca2f570656e6581760e1c089..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6668 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 t@k0q> diff --git a/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/module.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/modules/__pycache__/module.cpython-37.pyc deleted file mode 100644 index 5d8ab976f07bd03e2675234afd3e204d56ceeac0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7558 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 M-DoskYJB#;0p7EvJpcdz diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/__init__.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/__init__.cpython-37.pyc deleted file mode 100644 index 9cea4db19f3cb0a715e6bd7a159b2869f606be14..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 181 zcmZ?b<>g`kf*P+0$!C}t7#@Q-Fu(|8H~?`m3y?@*2xib^^jpbL1QJFNzvA>W@^e%5 zD>4&-RHj~eVqUs_N@{9BaY15Hc1CHEesY<9acXX2UP)$hd~s@eZfaghVo7Fxo_=O> zUTTScL1jsPQF4ZUZhlH?j(%xLW=^qwe0*kJW=VX!UP0w84jZ6MX-=vg$llLD%m4u4 CPBLo% diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/distributed.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/distributed.cpython-37.pyc deleted file mode 100644 index f5435a72926adbf52a7cd570664fef23d908b0b3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7644 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 diff --git a/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/registry.cpython-37.pyc b/cv/semantic_segmentation/icnet/pytorch/model/utils/__pycache__/registry.cpython-37.pyc deleted file mode 100644 index b88c49b4efc6d33a62acba9712d14e9344ce68b5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2260 zcma)7TW{k;6rQo2#O;XnA5C;kFYoHLG{7FB3RnHgs;=k|T)%>K&CGJ!Vx=C|l;`1%X~ zl+A&UUFiA?7&zfHA)R8T9ePN(#qBG?ZDC#79h=i*;yHiANz#sRESn7Ex3civIc zZYiu%<(INHJmVVL6D6V6?AytH7!6KkDmK6oTrZpN&*Sh)y`$d$QM*u67!X-N3v4)J zKY*^+V3^Sv2}n#}q=sGA^hIUYp6cnlRvNrFfF9l!04oaoWfwu#6>8P}wrAzF0Po~( z02B#;AF$+Tk#uth*Z&}@0apC;eXB2rqV;1O!W8>&!?f4pLX0%wxaWv7Q-;j z;wYGtApqofNfe(z-85uP6;|wBoZJGb}jde+XrZWroW^@}e7qZA|PoM3TEHW|T zZ2hN;b@n#YEKGpqd@_%gP=d2KEw)RGKldDkHs-5)8Zrj`e6EyKdA%#uFw7Jh=h+JF zQ*}IOLv&3fi^0XUX24}oG7;;7#-qe)(lt8$aN+r_Q|-!qRF54snW8cSrw6WjJhQs= z7t*Dsuq<8JGy9m#pwz(LlNmiD7uK)j8UsRaEDGfe3)b}aiV}rd$TDP4FFqGln8qoe zFIU8R16~0#NR%LW<5xlsAVp6FRuj%3q9TSHkhhGBNU9K+z~Gn4%xA|!FfJn?ER-cy z61B)hh$V;!dtxEDeJ4@S{}0grPhkN63HZ2*KwnVfBM<_8oFU{CxehEVY*j08!?QXo z-EkTPQUyk%fy$!=Y)E@$aB|S>L)3$R33X|mHtF=U3ZW81e;aCDnCKlJZ+MnkMHxnw zQwVM10-~(m!vS@a`iv^K6txRG8c&m&YpvBC8;K%WP+2_b#onl`I|g4_rmH`8!N=MJE23}^;`o?+Huzy2CIyA^MgaL61%X-u zVFqP|1=~2MKEkhs_R0i>Naz;!=%EO*JRFF$e{X2)~#Mk0GXNQS&-DrR0Uo^G>! UpTykVE)3jxgkmuUE_LmH0g@XkKmY&$ -- Gitee