Download do tgn - Download do código -fonte tgn

TGN: redes de gráficos temporais [Arxiv, YouTube, postagem do blog]

Gráfico dinâmico	TGN

Introdução

Apesar da infinidade de modelos diferentes para aprendizado profundo nos gráficos, poucas abordagens foram propostas até agora para lidar com gráficos que apresentam algum tipo de natureza dinâmica (por exemplo, recursos em evolução ou conectividade ao longo do tempo).

Neste artigo, apresentamos redes de gráficos temporais (TGNs), uma estrutura genérica e eficiente para aprendizado profundo em gráficos dinâmicos representados como sequências de eventos cronometrados. Graças a uma nova combinação de módulos de memória e operadores baseados em gráficos, os TGNs são capazes de superar significativamente as abordagens anteriores sendo ao mesmo tempo mais eficientes computacionalmente.

Além disso, mostramos que vários modelos anteriores para aprender em gráficos dinâmicos podem ser fundidos como instâncias específicas de nossa estrutura. Realizamos um estudo detalhado de ablação de diferentes componentes de nossa estrutura e elaboramos a melhor configuração que atinge o desempenho de ponta em várias tarefas de previsão transdutiva e indutiva para gráficos dinâmicos.

Link em papel: redes de gráficos temporais para aprendizado profundo em gráficos dinâmicos

Executando os experimentos

Requisitos

Dependências (com Python> = 3.7):

 pandas==1.1.0
torch==1.6.0
scikit_learn==0.23.1

Conjunto de dados e pré -processamento

Baixe os dados públicos

Faça o download dos dados de amostra (por exemplo, Wikipedia e Reddit) daqui e armazene seus arquivos CSV em uma pasta chamada data/ .

Pré -processo os dados

Usamos o denso formato npy para salvar os recursos em formato binário. Se os recursos da borda ou os recursos dos nós estiverem ausentes, eles serão substituídos por um vetor de zeros.

 python utils/preprocess_data.py --data wikipedia --bipartite
python utils/preprocess_data.py --data reddit --bipartite

Treinamento modelo

Aprendizagem auto-supervisionada usando a tarefa de previsão de link:

 # TGN-attn: Supervised learning on the wikipedia dataset
python train_self_supervised.py --use_memory --prefix tgn-attn --n_runs 10

# TGN-attn-reddit: Supervised learning on the reddit dataset
python train_self_supervised.py -d reddit --use_memory --prefix tgn-attn-reddit --n_runs 10

Aprendizagem supervisionada sobre classificação dinâmica dos nós (isso requer um modelo treinado da tarefa auto-supervisionada, por exemplo, executando os comandos acima):

 # TGN-attn: self-supervised learning on the wikipedia dataset
python train_supervised.py --use_memory --prefix tgn-attn --n_runs 10

# TGN-attn-reddit: self-supervised learning on the reddit dataset
python train_supervised.py -d reddit --use_memory --prefix tgn-attn-reddit --n_runs 10

Linhas de base

 ### Wikipedia Self-supervised

# Jodie
python train_self_supervised.py --use_memory --memory_updater rnn --embedding_module time --prefix jodie_rnn --n_runs 10

# DyRep
python train_self_supervised.py --use_memory --memory_updater rnn --dyrep --use_destination_embedding_in_message --prefix dyrep_rnn --n_runs 10


### Reddit Self-supervised

# Jodie
python train_self_supervised.py -d reddit --use_memory --memory_updater rnn --embedding_module time --prefix jodie_rnn_reddit --n_runs 10

# DyRep
python train_self_supervised.py -d reddit --use_memory --memory_updater rnn --dyrep --use_destination_embedding_in_message --prefix dyrep_rnn_reddit --n_runs 10


### Wikipedia Supervised

# Jodie
python train_supervised.py --use_memory --memory_updater rnn --embedding_module time --prefix jodie_rnn --n_runs 10

# DyRep
python train_supervised.py --use_memory --memory_updater rnn --dyrep --use_destination_embedding_in_message --prefix dyrep_rnn --n_runs 10


### Reddit Supervised

# Jodie
python train_supervised.py -d reddit --use_memory --memory_updater rnn --embedding_module time --prefix jodie_rnn_reddit --n_runs 10

# DyRep
python train_supervised.py -d reddit --use_memory --memory_updater rnn  --dyrep --use_destination_embedding_in_message --prefix dyrep_rnn_reddit --n_runs 10

Estudo de ablação

Comandos para replicar todos os resultados no estudo de ablação sobre diferentes módulos:

 # TGN-2l
python train_self_supervised.py --use_memory --n_layer 2 --prefix tgn-2l --n_runs 10 

# TGN-no-mem
python train_self_supervised.py --prefix tgn-no-mem --n_runs 10 

# TGN-time
python train_self_supervised.py --use_memory --embedding_module time --prefix tgn-time --n_runs 10 

# TGN-id
python train_self_supervised.py --use_memory --embedding_module identity --prefix tgn-id --n_runs 10

# TGN-sum
python train_self_supervised.py --use_memory --embedding_module graph_sum --prefix tgn-sum --n_runs 10

# TGN-mean
python train_self_supervised.py --use_memory --aggregator mean --prefix tgn-mean --n_runs 10

Bandeiras gerais

 optional arguments:
  -d DATA, --data DATA         Data sources to use (wikipedia or reddit)
  --bs BS                      Batch size
  --prefix PREFIX              Prefix to name checkpoints and results
  --n_degree N_DEGREE          Number of neighbors to sample at each layer
  --n_head N_HEAD              Number of heads used in the attention layer
  --n_epoch N_EPOCH            Number of epochs
  --n_layer N_LAYER            Number of graph attention layers
  --lr LR                      Learning rate
  --patience                   Patience of the early stopping strategy
  --n_runs                     Number of runs (compute mean and std of results)
  --drop_out DROP_OUT          Dropout probability
  --gpu GPU                    Idx for the gpu to use
  --node_dim NODE_DIM          Dimensions of the node embedding
  --time_dim TIME_DIM          Dimensions of the time embedding
  --use_memory                 Whether to use a memory for the nodes
  --embedding_module           Type of the embedding module
  --message_function           Type of the message function
  --memory_updater             Type of the memory updater
  --aggregator                 Type of the message aggregator
  --memory_update_at_the_end   Whether to update the memory at the end or at the start of the batch
  --message_dim                Dimension of the messages
  --memory_dim                 Dimension of the memory
  --backprop_every             Number of batches to process before performing backpropagation
  --different_new_nodes        Whether to use different unseen nodes for validation and testing
  --uniform                    Whether to sample the temporal neighbors uniformly (or instead take the most recent ones)
  --randomize_features         Whether to randomize node features
  --dyrep                      Whether to run the model as DyRep

Todos

Torne a memória do código eficiente: Por uma questão de simplicidade, o módulo de memória do modelo TGN é implementado como um parâmetro (para que seja armazenado e carregado juntos do modelo). No entanto, isso não precisa ser o caso, e implementações mais eficientes que tratam os modelos como apenas tensores (da mesma maneira que os recursos de entrada) seriam mais passíveis de gráficos grandes.

Cite -nos

 @inproceedings { tgn_icml_grl2020 ,
    title = { Temporal Graph Networks for Deep Learning on Dynamic Graphs } ,
    author = { Emanuele Rossi and Ben Chamberlain and Fabrizio Frasca and Davide Eynard and Federico 
    Monti and Michael Bronstein } ,
    booktitle = { ICML 2020 Workshop on Graph Representation Learning } ,
    year = { 2020 }
}