code: def __init__(self):
      super(resnext101_32x4d_features, self).__init__()
  
      self.resnext101_32x4d_stem = nn.Sequential(  # Sequential,
          nn.Conv2d(3, 64, (7, 7), (2, 2), (3, 3), 1, 1, bias=False),
          nn.BatchNorm2d(64),
          nn.ReLU(),
          nn.MaxPool2d((3, 3), (2, 2), (1, 1)),
      )
  
      self.resnext101_32x4d_layer1 = nn.Sequential(  # Sequential,
          nn.Sequential(  # Sequential,
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  64,
                                  128,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(128),
                              nn.ReLU(),
                              nn.Conv2d(
                                  128,
                                  128,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(128),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              128,
                              256,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(256),
                      ),
                      nn.Sequential(  # Sequential,
                          nn.Conv2d(
                              64,
                              256,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(256),
                      ),
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  256,
                                  128,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(128),
                              nn.ReLU(),
                              nn.Conv2d(
                                  128,
                                  128,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(128),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              128,
                              256,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(256),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  256,
                                  128,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(128),
                              nn.ReLU(),
                              nn.Conv2d(
                                  128,
                                  128,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(128),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              128,
                              256,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(256),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
          )
      )
  
      self.resnext101_32x4d_layer2 = nn.Sequential(  # Sequential,
          nn.Sequential(  # Sequential,
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  256,
                                  256,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                              nn.Conv2d(
                                  256,
                                  256,
                                  (3, 3),
                                  (2, 2),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              256,
                              512,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(512),
                      ),
                      nn.Sequential(  # Sequential,
                          nn.Conv2d(
                              256,
                              512,
                              (1, 1),
                              (2, 2),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(512),
                      ),
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  512,
                                  256,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                              nn.Conv2d(
                                  256,
                                  256,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              256,
                              512,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(512),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  512,
                                  256,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                              nn.Conv2d(
                                  256,
                                  256,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              256,
                              512,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(512),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  512,
                                  256,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                              nn.Conv2d(
                                  256,
                                  256,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(256),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              256,
                              512,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(512),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
          )
      )
  
      self.resnext101_32x4d_layer3 = nn.Sequential(  # Sequential,
          nn.Sequential(  # Sequential,
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  512,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (2, 2),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      nn.Sequential(  # Sequential,
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (2, 2),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  512,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                              nn.Conv2d(
                                  512,
                                  512,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(512),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              512,
                              1024,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(1024),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
          )
      )
  
      self.resnext101_32x4d_layer4 = nn.Sequential(  # Sequential,
          nn.Sequential(  # Sequential,
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  1024,
                                  1024,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(1024),
                              nn.ReLU(),
                              nn.Conv2d(
                                  1024,
                                  1024,
                                  (3, 3),
                                  (2, 2),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(1024),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              1024,
                              2048,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(2048),
                      ),
                      nn.Sequential(  # Sequential,
                          nn.Conv2d(
                              1024,
                              2048,
                              (1, 1),
                              (2, 2),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(2048),
                      ),
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  2048,
                                  1024,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(1024),
                              nn.ReLU(),
                              nn.Conv2d(
                                  1024,
                                  1024,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(1024),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              1024,
                              2048,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(2048),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
              nn.Sequential(  # Sequential,
                  LambdaMap(
                      lambda x: x,  # ConcatTable,
                      nn.Sequential(  # Sequential,
                          nn.Sequential(  # Sequential,
                              nn.Conv2d(
                                  2048,
                                  1024,
                                  (1, 1),
                                  (1, 1),
                                  (0, 0),
                                  1,
                                  1,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(1024),
                              nn.ReLU(),
                              nn.Conv2d(
                                  1024,
                                  1024,
                                  (3, 3),
                                  (1, 1),
                                  (1, 1),
                                  1,
                                  32,
                                  bias=False,
                              ),
                              nn.BatchNorm2d(1024),
                              nn.ReLU(),
                          ),
                          nn.Conv2d(
                              1024,
                              2048,
                              (1, 1),
                              (1, 1),
                              (0, 0),
                              1,
                              1,
                              bias=False,
                          ),
                          nn.BatchNorm2d(2048),
                      ),
                      Lambda(lambda x: x),  # Identity,
                  ),
                  LambdaReduce(lambda x, y: x + y),  # CAddTable,
                  nn.ReLU(),
              ),
          )
      )
  
imports: import torch
  import torch.nn
  from torch.autograd import Variable
  from functools import reduce
label_desc: Use image node_id 1 to create a new resnext101_32x4d_features object from inherited base classes: nn with example: obj = resnext101_32x4d_features()