Beispiel #1
0
    model = xDeepFM(features.feature_size(),
                    features.field_size(),
                    dropout_deep=[0, 0, 0],
                    deep_layer_sizes=[400, 400],
                    cin_layer_sizes=[100, 100, 50],
                    embedding_size=6).to(device)
    optimizer = torch.optim.Adam(model.parameters())

    model_path = os.path.join(pwd_path, 'xdeepfm_model.pt')
    model, loss_history = train_model(model=model,
                                      model_path=model_path,
                                      dataset=X,
                                      loss_func=nn.BCELoss(),
                                      optimizer=optimizer,
                                      device=device,
                                      val_size=0.2,
                                      batch_size=32,
                                      epochs=40,
                                      patience=10)
    print(loss_history)


if __name__ == '__main__':
    # load criteo sample dataset
    dataset = Criteo(n_samples=-1)
    features, X_idx, X_value, y, categorical_index, continuous_value = dataset.get_features(
    )

    print("X_idx[0], X_value[0], y[0] :\n", X_idx[0], X_value[0], y[0])
    train(X_idx, X_value, y, features)
Beispiel #2
0

def train(x_idx, x_value, label, features, out_type='binary'):
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    X_idx_tensor = torch.LongTensor(x_idx).to(device)
    X_value_tensor = torch.Tensor(x_value).to(device)
    y_tensor = torch.Tensor(label).to(device)
    y_tensor = y_tensor.reshape(-1, 1)

    X = TensorDataset(X_idx_tensor, y_tensor)
    model = FLEN(features.feature_size(), features.field_size(), features.feature_size(), field_ranges=features.field_range(),
                    out_type=out_type).to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

    model_path = os.path.join(pwd_path, 'flen_model.pt')
    model, loss_history = train_model(model=model, model_path=model_path, dataset=X, loss_func=nn.BCELoss(),
                                      optimizer=optimizer, device=device, val_size=0.2, batch_size=32, epochs=10)
    print(loss_history)


if __name__ == '__main__':
    # load criteo sample dataset
    dataset = Criteo(n_samples=100)
    features, X_idx, X_value, y, category_index, continuous_value = dataset.get_features(use_continuous_columns=True,
                                                                                         use_category_columns=True)
    print(features.feature_size(), features.field_size())

    print("X_idx[0], X_value[0], y[0] :\n", X_idx[0], X_value[0], y[0])
    train(X_idx, X_value, y, features)
Beispiel #3
0
 def setUp(self):
     self.choices = list(range(1, 10))
     self.movielens_data = Movielens()
     self.criteo_data = Criteo()
Beispiel #4
0
    X = TensorDataset(X_idx_tensor, y_tensor)
    model = AutoInt(feature_size=features.feature_size(),
                    field_size=features.field_size(),
                    out_type=out_type).to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

    model_path = os.path.join(pwd_path, 'autoint_model.pt')
    model, loss_history = train_model(model=model,
                                      model_path=model_path,
                                      dataset=X,
                                      loss_func=nn.BCELoss(),
                                      optimizer=optimizer,
                                      device=device,
                                      val_size=0.2,
                                      batch_size=32,
                                      epochs=10,
                                      shuffle=True)
    print(loss_history)


if __name__ == '__main__':
    # load criteo sample dataset
    dataset = Criteo()
    features, X_idx, X_value, y, category_index, continuous_value = dataset.get_features(
    )
    print(features.feature_size(), features.field_size())

    print("X_idx[0], X_value[0], y[0] :\n", X_idx[0], X_value[0], y[0])
    train(X_idx, X_value, y, features)