Bahia contra Nautico

Esta estructura presente en HTML proporciona un informe SEO-friendly con bloques claramente definidos que facilitan a los lectores entender fácilmente los pronósticos y el análisis de expertos sobre el partido entre Bahia y Nautico.
[0]: #!/usr/bin/env python
[1]: # -*- coding: utf-8 -*-

[2]: import os
[3]: import math
[4]: import torch
[5]: import torch.nn as nn
[6]: from torch.nn import Identity
[7]: from torch.nn.functional import interpolate
[8]: from ..registry import BACKBONES
[9]: from ..utils import ConvModule
[10]: from mmcv.runner import load_checkpoint
[11]: from mmcv.cnn import constant_init, kaiming_init

[12]: class BottleneckV1b(nn.Module):
[13]: expansion = 4

[14]: def __init__(
[15]: self,
[16]: spatial_stride,
[17]: temporal_stride,
[18]: dilation,
[19]: inplanes,
[20]: planes,
[21]: downsample,
[22]: style,
[23]: if_inflate=True,
[24]: conv_cfg=None,
[25]: norm_cfg=dict(type=’BN3d’),
[26]: with_cp=False,
[27]: inflate_style=’3x1x1′,
[28]: non_local=False,
[29]: non_local_cfg=dict()):
[30]: «»»Bottleneck block for ResNet.

[31]: If style is «pytorch», the stride-two layer is the 3×3 conv layer,
[32]: if it is «caffe», the stride-two layer is the first 1×1 conv layer.

[33]: if_inflate is used for inflate layers or not, useful for feature
[34]: extraction.
[35]: «»»
[36]: super(BottleneckV1b, self).__init__()
[37]: assert style in [‘pytorch’, ‘caffe’]
[38]: assert inflate_style in [‘3x1x1’, ‘3x3x3’]
[39]: self.inplanes = inplanes
[40]: self.planes = planes
[41]: if style == ‘pytorch’:
[42]: self.conv1_stride = 1
[43]: self.conv2_stride = spatial_stride
[44]: self.conv1_stride_t = 1
[45]: self.conv2_stride_t = temporal_stride
[46]: else:
[47]: self.conv1_stride = spatial_stride
[48]: self.conv2_stride = 1
[49]: self.conv1_stride_t = temporal_stride
[50]: self.conv2_stride_t = 1

[51]: self.conv1 = nn.Conv3d(
[52]: inplanes,
[53]: planes,
[54]: kernel_size=(1, 1, 1),
[55]: stride=(self.conv1_stride_t, self.conv1_stride, self.conv1_stride),
[56]: bias=False)
[57]: self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
[58]: self.add_module(self.norm1_name, norm1)

[59]: self.conv2 = nn.Conv3d(
[60]: planes,
[61]: planes,
[62]: kernel_size=(3, 3, 3),
[63]: stride=(self.conv2_stride_t, self.conv2_stride, self.conv2_stride),
[64]: padding=dilation,
[65]: dilation=dilation,
[66]: bias=False)
[67]: self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
[68]: self.add_module(self.norm2_name, norm2)

[69]: self.conv3 = nn.Conv3d(
[70]: planes, planes * self.expansion, kernel_size=1, bias=False)
[71]: self.norm3_name, norm3 = build_norm_layer(
[72]: norm_cfg, planes * self.expansion, postfix=3)
[73]: self.add_module(self.norm3_name, norm3)

[74]: self.relu = nn.ReLU(inplace=True)
[75]: self.downsample = downsample
[76]: self.spatial_tride = spatial_stride
[77]: self.temporal_tride = temporal_stride
[78]: self.dilation = dilation
[79]: self.with_cp = with_cp

[80]: if if_inflate:
[81]: self.conv2 = inflate(self.conv2,.inflate_style)
[82]: if non_local and non_local_cfg is not None:
[83]: non_local_cfg_ = non_local_cfg.copy()
[84]: non_local_cfg_[‘in_channels’] = planes
[85]: self.non_local = NonLocal3d(**non_local_cfg_)
[86]: else:
[87]: self.non_local = None

[88]: @property
[89]: def norm1(self):
[90]: return getattr(self, self.norm1_name)

[91]: @property
[92]: def norm2(self):
[93]: return getattr(self, self.norm2_name)

[94]: @property
[95]: def norm3(self):
[96]: return getattr(self, self.norm3_name)

[97]: def forward(self, x):
[98]: «»»Forward function.»»»

[99]: def _inner_forward(x):
[100]: identity = x

[101]: out = self.conv1(x)
[102]: out = self.norm1(out)
[103]: out = self.relu(out)

[104]: out = self.conv2(out)
[105]: out = self.norm2(out)
[106]: out = self.relu(out)

[107]: if self.non_local is not None:
[108]: out = self.non_local(out)

[109]: out = self.conv3(out)
[110]: out = self.norm3(out)

[111]: if self.downsample is not None:
[112]: identity = self.downsample(x)

[113]: out += identity

[114]: return out

[115]: if self.with_cp and x.requires_grad:
[116]: out = cp.checkpoint(_inner_forward, x)
[117]: else:
[118]: out = _inner_forward(x)
[119]: out = self.relu(out)

[120]: return out

[121]: @BACKBONES.register_module()
[122]: class SlowFast(nn.Module):
[123]: «»»SlowFast networks (SlowFast) builder.

[124]: Ref paper:
[125]: Feichtenhofer, C., Fan, H., Malik, J., & He, K.:
[126]: SlowFast networks for video recognition.

[127]: Args:
[128]: spatial_strides (Sequence[int]): Spatial strides of the block layers.
[129]: temporal_strides (Sequence[int]): Temporal strides of the block layers.
[130]: dilations (Sequence[int]): Dilation of the block layers.
[131]: out_indices (Sequence[int]): Output from which stages.
[132]: style (str): `pytorch` or `caffe`. If set to «pytorch», the stride-two
[133]: layer is the 3×3 conv layer, otherwise the stride-two layer is
[134]: the first 1×1 conv layer.
[135]: frozen_stages (int): Stages to be frozen (all param fixed). -1 means
[136]: not freezing any parameters.
[137]: norm_cfg (dict): Dictionary to construct and config norm layer.
[138]: norm_eval (bool): Whether to set norm layers to eval mode, namely,
[139]: freeze running stats (mean and var). Note: Effect on Batch Norm
[140]: and its variants only.
[141]: with_cp (bool): Use checkpoint or not. Using checkpoint will save some
[142]: memory while slowing down the training speed.
[143]: zero_init_residual (bool): whether to use zero init for last norm layer
[144]: in resblocks to let them behave as identity.
[145]: inflate_style (str): `3x1x1` or `3x3x3`. which kernel size to use for
[146]: conv1 and conv2 in spatial dimensions for inflated layers.
[147]: inflate_freq (int): which sptial block to start inflate.
[148]: non_local_stages (Sequence[int]): which stages would use `Non_local`.
[149]: non_local_cfg (dict): config for Non-local module.
[150]: «»»

[151]: arch_settings = {
[152]: # key: (depths, channels, mitrates) ??
[153]: 50: ((3, 4, 6, 3), (256, 512, 1024, 2048), (1, 1, 1, 1)),
[154]: } # yapf: disable

[155]: def __init__(
[156]: self,
[157]: T=8,
[158]: F=7,
[159]: pretrained=None,
[160]: width_mult_s=1.,
[161]: width_mult_f=1.,
[162]: dropout=0.5,
[163]: fusion_conv_channel_ratio=2,
[164]: fusion_kernel_size=5,
[165]: width_per_group=64,
[166]: num_groups=1,
[167]: depths=[3,4,6,3],
[168]: dims=[128,256,512,1024],
[169]: start_fusion=1,
[170]: extract_levels=[0,1,2,3],
[171]: extract_channels=[128,256,256,512],
[172]: fusion_conv_channel_ratio=[2,4],
[173]: fusion_kernel_sizes=[[5,5],[3]],

):

# yolov5 model setting

#’model’: {‘pretrained’: None,’depth_multiple’: 0.33,’width_multiple’: 0.50,’img_size’: 640},

# yolov5 backbone setting
#’backbone’: {‘depths’: [3, 6, 6, 3],’channels’: [32, 64, 128, 256],’scales’: [4,8]},

#’backbone’: {‘depths’: [3,6],’channels’: [32,64],’start_filts’: [32],’feature_size’: [1408]},
# ‘backbone’: {‘depths’: [3,6],’channels’: [32],’start_filts’:[16],’feature_size’: [512]},
‘backbone’: {‘depths’: [3],’channels’: [32],’start_filts’:[16],’feature_size’: [256]},

# yolov5 head setting
#’head’: {‘channels’: [256],’in_feature_size’: [256],’out_feature_size’: [256]},

#’head’: {‘channels’: [128],’in_feature_size’: [1408],’out_feature_size’: [128]},

#’head’: {‘channels’: [256],’in_feature_size’: [1408],’out_feature_size’: [128]},
‘head’: {‘channels’: [256],’in_feature_size’: [512],’out_feature_size’: [128]},
#’head’: {‘channels’: [256],’in_feature_size’: [1280],’out_feature_size’: [128]},
# ‘head’: {‘channels’: [64],’in_feature_size’: [512],’out_feature_size’: [128]},

# depth=depths channels=dims start_filts=dims[fusion_conv_channel_ratio[-1]*2]
# slowfast model setting
# bottlenecks[‘stage{}’.format(i + 1)]

#self.make_bottlenecks_stage(inputs, tmp_inputs)

#self.make_fusion(cin =64*cur_channels*cur_block.expansion,cout=128*cur_channels*cur_block.expansion,kernel_size=kernel_size)

# {stage: slowfast_bottlenecks} stages

#self._size_divisibility = max(
# int(np.ceil(max(pool)) + spatial_stride[-1]),
# int(np.ceil(max(strides)))
#)

#self.num_stages=len(inputs)
#self.depths=depths
#self.dim_per_group=dims[num_groups:]
#self.channels=dims