text: import os
  import torch
  import torch.nn as nn
  import numpy as np
  import math
  import PIL
  
  
  def dir_exists(path):
      """
      功能：判断文件夹是否存在，如果不存在创建
      """
      if not os.path.exists(path):
              os.makedirs(path)
  
  
  def initialize_weights(*models):
      """
      功能：初始化权重
      """
      for model in models:
          for m in model.modules():
              if isinstance(m, nn.Conv2d):
                  nn.init.kaiming_normal_(m.weight.data, nonlinearity='relu')
              elif isinstance(m, nn.BatchNorm2d):
                  m.weight.data.fill_(1.)
                  m.bias.data.fill_(1e-4)
              elif isinstance(m, nn.Linear):
                  m.weight.data.normal_(0.0, 0.0001)
                  m.bias.data.zero_()
  
  
  def colorize_mask(mask, palette):
      """
      功能：为mask图，填充颜色
      """
      zero_pad = 256 * 3 - len(palette)
      for i in range(zero_pad):
                      palette.append(0)
      new_mask = PIL.Image.fromarray(mask.astype(np.uint8)).convert('P')
      new_mask.putpalette(palette)
      return new_mask
  
  
  def get_upsampling_weight(in_channels, out_channels, kernel_size):
      factor = (kernel_size + 1) // 2
      if kernel_size % 2 == 1:
              center = factor - 1
      else:
              center = factor - 0.5
      og = np.ogrid[:kernel_size, :kernel_size]
      filt = (1 - abs(og[0] - center) / factor) * (1 - abs(og[1] - center) / factor)
      weight = np.zeros((in_channels, out_channels, kernel_size, kernel_size), dtype=np.float64)
      weight[list(range(in_channels)), list(range(out_channels)), :, :] = filt
      return torch.from_numpy(weight).float()
  
  
  
  
  
  def set_trainable_attr(m,b):
      m.trainable = b
      for p in m.parameters(): p.requires_grad = b
  
  
  def apply_leaf(m, f):
      c = m if isinstance(m, (list, tuple)) else list(m.children())
      if isinstance(m, nn.Module):
          f(m)
      if len(c)>0:
          for l in c:
              apply_leaf(l,f)
  
  
  def set_trainable(l, b):
      """
      功能：freeze网络（l是list列表，其中元素是modules）
      """
      apply_leaf(l, lambda m: set_trainable_attr(m, b))