Here is my complete YOLO model given below, could you please specify, if possible:

class YOLOLayer(nn.Module):
    def __init__(self, anchors, number_of_classes, img_size):
        """
            anchors: list of anchers to be used by this detection-layer
            number_of_classes: total number of classes that the network can detect
            img_size: (width, height) of the detection layer(input-image)
        """
        super(MyYoloModel.YOLOLayer, self).__init__()

        self.anchors = torch.FloatTensor(anchors)
        self.number_of_anchers = len(anchors) #number of anchors (3) per Yolo-detection-layer
        self.number_of_classes = number_of_classes # number of classes
        self.nx = 0  # initialize number of x gridpoints
        self.ny = 0  # initialize number of y gridpoints


    def forward(self, p, img_size):
        batch_size, ny, nx = p.shape[0], p.shape[-2], p.shape[-1] #get information about the input matrix

        #check if we need to calculate the grid
        if (self.nx, self.ny) != (nx, ny):
            NNtools.create_grids(self, img_size, (nx, ny), p.device, p.dtype)

        # p.view(batch_size, 255, 13, 13) -- > (batch_size, 3, 13, 13, 85)  # (batch_size, anchors, grid, grid, classes + xywh)
        p = p.view(batch_size, self.number_of_anchers, self.number_of_classes + 5, self.ny, self.nx).permute(0, 1, 3, 4, 2).contiguous()  # prediction

        #check if we are training of running inference on the network
        if self.training:
            return p
        else: # inference
            io = p.clone()  # inference output
            io[..., 0:2] = torch.sigmoid(io[..., 0:2]) + self.grid_xy  # xy
            io[..., 2:4] = torch.exp(io[..., 2:4]) * self.anchor_wh  # wh yolo method
            io[..., :4] *= self.stride

            torch.sigmoid_(io[..., 4:])

            if self.number_of_classes == 1:
                io[..., 5] = 1  # single-class model 

            # reshape from [1, 3, 13, 13, 85] to [1, 507, 85]
            return io.view(batch_size, -1, 5 + self.number_of_classes), p




def Get_YOLO_layers_list(self):
    """
        Returns a list with the layers of the model that are of the 'YOLOLayer'-class
    """
    detector_list = []
    for layer in self.children():
        if type(layer) is self.YOLOLayer:
                detector_list.append(layer) #add the instance of this 'YOLOLayer' to the list

    return detector_list