content: import torch
  import torch.nn as nn
  from torch.autograd import Variable
  import numpy as np
  
  
  class RoIPool(nn.Module):
      def __init__(self, pooled_height, pooled_width, spatial_scale):
          super(RoIPool, self).__init__()
          self.pooled_width = int(pooled_width)
          self.pooled_height = int(pooled_height)
          self.spatial_scale = float(spatial_scale)
  
      def forward(self, features, rois):
          batch_size, num_channels, data_height, data_width = features.size()
          num_rois = rois.size()[0]
          outputs = Variable(torch.zeros(num_rois, num_channels, self.pooled_height, self.pooled_width)).cuda()
  
          for roi_ind, roi in enumerate(rois):
              batch_ind = int(roi[0].data[0])
              roi_start_w, roi_start_h, roi_end_w, roi_end_h = np.round(
                  roi[1:].data.cpu().numpy() * self.spatial_scale).astype(int)
              roi_width = max(roi_end_w - roi_start_w + 1, 1)
              roi_height = max(roi_end_h - roi_start_h + 1, 1)
              bin_size_w = float(roi_width) / float(self.pooled_width)
              bin_size_h = float(roi_height) / float(self.pooled_height)
  
              for ph in range(self.pooled_height):
                  hstart = int(np.floor(ph * bin_size_h))
                  hend = int(np.ceil((ph + 1) * bin_size_h))
                  hstart = min(data_height, max(0, hstart + roi_start_h))
                  hend = min(data_height, max(0, hend + roi_start_h))
                  for pw in range(self.pooled_width):
                      wstart = int(np.floor(pw * bin_size_w))
                      wend = int(np.ceil((pw + 1) * bin_size_w))
                      wstart = min(data_width, max(0, wstart + roi_start_w))
                      wend = min(data_width, max(0, wend + roi_start_w))
  
                      is_empty = (hend <= hstart) or(wend <= wstart)
                      if is_empty:
                          outputs[roi_ind, :, ph, pw] = 0
                      else:
                          data = features[batch_ind]
                          outputs[roi_ind, :, ph, pw] = torch.max(
                              torch.max(data[:, hstart:hend, wstart:wend], 1)[0], 2)[0].view(-1)
  
          return outputs
  
  