PyTorch : Aggregate dos modelos

Hola y saludos de Grecia

class Model(nn.Module):

def __init__(self, embedding_size, num_numerical_cols, output_size, layers, p=0.4):
    super().__init__()
    self.all_embeddings = nn.ModuleList([nn.Embedding(ni, nf) for ni, nf in embedding_size])
    self.embedding_dropout = nn.Dropout(p)
    self.batch_norm_num = nn.BatchNorm1d(num_numerical_cols)

    all_layers = []
    num_categorical_cols = sum((nf for ni, nf in embedding_size))
    input_size = num_categorical_cols + num_numerical_cols

    for i in layers:
        all_layers.append(nn.Linear(input_size, i))
        all_layers.append(nn.ReLU(inplace=True))
        all_layers.append(nn.BatchNorm1d(i))
        all_layers.append(nn.Dropout(p))
        input_size = i

    all_layers.append(nn.Linear(layers[-1], output_size))

    self.layers = nn.Sequential(*all_layers)

def forward(self, x_categorical, x_numerical):
    embeddings = []
    for i,e in enumerate(self.all_embeddings):
        embeddings.append(e(x_categorical[:,i]))
    x = torch.cat(embeddings, 1)
    x = self.embedding_dropout(x)

    x_numerical = self.batch_norm_num(x_numerical)
    x = torch.cat([x, x_numerical], 1)
    x = self.layers(x)
    return x

Supongamos que tengo esta nn para la clasificación y creo dos casos

model_1=Model(categorical_embedding_sizes, numerical_data.shape[1], 2, [200,100,50], p=0.4)
model_2=Model(categorical_embedding_sizes, numerical_data.shape[1], 2, [200,100,50], p=0.4)

Y después de entrenar estos dos modelos los salvé con torch.save como model_1.pt y model_2.pt¿Hay una manera de crear un nuevo modelo con los parámetros medios de los dos modelos?

algo como

model_new.weight=(model_1.weight+model_2.weight)/2
model_new.bias=(model_1.bias+model_2.bias)/2

Gracias por adelantado

Pregunta hecha hace 3 años, 4 meses, 29 días - Por pixelpilot

3 Respuestas:

• Usted puede hacer esto fácilmente generando un diccionario estatal de sus dos diccionarios estatales:

  state_1 = model_1.state_dict()
  state_2 = model_2.state_dict()
  
  for layer in state_1:
      state_1[layer] = (state_1[layer] + state_2[layer])/2
  

  Lo anterior se inclinará a través de parámetros (pesos y sesgos) de todas las capas.

  Entonces sobreescribir este nuevo estado en ambos model_1 o un modelo de nueva instancia, así:

  model_new = Model(categorical_embedding_sizes, numerical_data.shape[1], 2, [200,100,50], p=0.4)
  model_new.load_state_dict(state1)
  

  Respondida el Dec 18, 2020 a las 10:11 - por codecanvas

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• Para combinar los parámetros medios de dos modelos PyTorch, puedes seguir los siguientes pasos:

  • Cargar los modelos guardados usando `torch.load`.

  python
  model_1 = torch.load('model_1.pt')
  model_2 = torch.load('model_2.pt')
  

  • Crear un nuevo modelo con los mismos parámetros que los modelos originales.

  python
  model_new = Model(categorical_embedding_sizes, numerical_data.shape[1], 2, [200,100,50], p=0.4)
  

  • Calcular los parámetros medios y asignarlos al nuevo modelo.

  python
  for param_new, param_1, param_2 in zip(model_new.parameters(), model_1.parameters(), model_2.parameters()):
      param_new.data = (param_1.data + param_2.data) / 2
  

  Con estos pasos, has creado un nuevo modelo model_new con los parámetros medios de model_1 y model_2. Ahora puedes usar este nuevo modelo para realizar inferencias en tus datos.

  Respondida el Dec 19, 2020 a las 10:11 - por Gpt

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• Claro, puedes crear un nuevo modelo con los parámetros promedio de dos modelos existentes utilizando el siguiente código:

  python
  import torch
  
  Cargar los dos modelos entrenados
  model_1 = torch.load('model_1.pt')
  model_2 = torch.load('model_2.pt')
  
  Crear un nuevo modelo con la misma arquitectura
  model_new = Model(categorical_embedding_sizes, numerical_data.shape[1], 2, [200,100,50], p=0.4)
  
  Promediar los pesos y sesgos de los dos modelos
  for param_name in model_new.state_dict():
      param_1 = model_1.state_dict()[param_name]
      param_2 = model_2.state_dict()[param_name]
      model_new.state_dict()[param_name].copy_((param_1 + param_2) / 2)
  
  Guardar el nuevo modelo
  torch.save(model_new, 'model_new.pt')
  

  Este código recorrerá todos los parámetros del nuevo modelo y los promediará con los parámetros correspondientes de los dos modelos existentes. Luego guardará el nuevo modelo con los parámetros promedio.

  Respondida el Dec 19, 2020 a las 10:14 - por Gemini

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---