es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Cómo hacer que los datos “one-hot” sean compatibles con datos que no son “one-hot”?

Estoy creando un modelo de aprendizaje automático para calcular la tasa de victorias en un juego según la combinación de personajes. Tengo un error en la última línea al usar la función de pérdida. Creo que es porque la entrada es un vector one-hot. La salida del modelo no es compatible con los datos objetivo, ya que los datos objetivo son simplemente valores booleanos, ganar o perder. Por favor, dame consejos para superar este problema. ¿Cómo puedo hacer que la entrada one-hot sea compatible con los datos que no son one-hot?

‘por ejemplo, cuando el número de personajes es 4 y cada miembro del equipo es 2.
x_data es [ [[0,0,1,0], [0,1,0,0], [1,0,0,0,],[0,1,0,0]], [juego2]…]
equipo A1, equipo A2, equipo B1, equipo B2

y_data = [[0], [0], [0], [1], [1], [1]] # equipo azul gana: 1, pierde: 0
x_train = torch.FloatTensor(x_data)
y_train = torch.FloatTensor(y_data)

class BinaryClassifier(nn.Module):
def init(self):
super(BinaryClassifier, self).init()

    self.layer1 = nn.Sequential(
        nn.Linear(in_features=num_characters, out_features=10, bias=True),
        nn.ReLU(), 
        )

    self.layer2 = nn.Sequential(
        nn.Linear(in_features=10, out_features=1, bias=True),
        nn.Sigmoid(), 
        )

def forward(self, x):
    x = self.layer1(x) 
    x = self.layer2(x)
    return torch.sigmoid(x)

model = BinaryClassifier()
optimizer = optim.SGD(model.parameters(), lr=1)

nb_epochs = 1000
for epoch in range(nb_epochs + 1):

hypothesis = model(x_train)
cost = nn.BCELoss(hypothesis, y_train)

# RuntimeError: el valor bool de un tensor con más de un valor es ambiguo

Tags:  , , , ,

Answer

  1. Avatar for davy.ai

    Para hacer que la entrada one-hot sea compatible con la salida no one-hot, puedes modificar la capa de salida de tu modelo para tener solo una neurona que prediga la probabilidad de ganar. Luego, puedes usar una función de pérdida de entropía cruzada binaria (BCELoss) para calcular la diferencia entre la probabilidad predicha y el resultado real (ganar o perder).

    Para corregir el error en tu código, debes pasar los valores predichos y los valores objetivo por separado a la función BCELoss, de esta manera:

    cost = nn.BCELoss()(hypothesis, y_train)
    

    Observa los paréntesis adicionales después de BCELoss, que crean una instancia de la función de pérdida con los parámetros por defecto.

    Además, debes actualizar los pesos de tu modelo en cada época calculando los gradientes de la pérdida con respecto a los parámetros y aplicándolos utilizando el optimizador:

    optimizer.zero_grad()
    cost.backward()
    optimizer.step()
    

    Esto ayudará al modelo a aprender a predecir el resultado del juego basado en las composiciones de los equipos.

Comments are closed.