Merge branch 'master' into 0.4.x

Author: BarclayII

CMakeLists.txt

@@ -25,6 +25,10 @@ endif()
 dgl_option(USE_CUDA "Build with CUDA" OFF)
 dgl_option(USE_OPENMP "Build with OpenMP" ON)
 dgl_option(BUILD_CPP_TEST "Build cpp unittest executables" OFF)
+# Set debug compile option for gdb, only happens when -DCMAKE_BUILD_TYPE=DEBUG
+if (NOT MSVC)
+ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g3 -ggdb")
+endif(NOT MSVC)
 
 if(USE_CUDA)
   message(STATUS "Build with CUDA support")
@@ -83,7 +87,6 @@ endif(USE_OPENMP)
 
 # configure minigun
 add_definitions(-DENABLE_PARTIAL_FRONTIER=0)  # disable minigun partial frontier compile
-
 # Source file lists
 file(GLOB DGL_SRC
   src/*.cc

CONTRIBUTORS.md

@@ -19,6 +19,7 @@ Contributors
 * [Aymen Waheb](https://github.com/aymenwah): APPNP in Pytorch
 * [Chengqiang Lu](https://github.com/geekinglcq): MGCN, SchNet and MPNN in PyTorch
 * [Gongze Cao](https://github.com/Zardinality): Cluster GCN
+* [Yicheng Wu](https://github.com/MilkshakeForReal): RotatE in Pytorch
 
 Other improvement
 * [Brett Koonce](https://github.com/brettkoonce)

Jenkinsfile

@@ -1,6 +1,6 @@
 #!/usr/bin/env groovy
 
-dgl_linux_libs = "build/libdgl.so, build/runUnitTests, python/dgl/_ffi/_cy3/core.cpython-35m-x86_64-linux-gnu.so"
+dgl_linux_libs = "build/libdgl.so, build/runUnitTests, python/dgl/_ffi/_cy3/core.cpython-36m-x86_64-linux-gnu.so"
 // Currently DGL on Windows is not working with Cython yet
 dgl_win64_libs = "build\\dgl.dll, build\\runUnitTests.exe"
 
@@ -56,7 +56,7 @@ def cpp_unit_test_win64() {
 def unit_test_linux(backend, dev) {
   init_git()
   unpack_lib("dgl-${dev}-linux", dgl_linux_libs)
-  timeout(time: 5, unit: 'MINUTES') {
+  timeout(time: 10, unit: 'MINUTES') {
     sh "bash tests/scripts/task_unit_test.sh ${backend} ${dev}"
   }
 }
@@ -101,11 +101,17 @@ def tutorial_test_linux(backend) {
   }
 }
 
+
 pipeline {
   agent any
   stages {
     stage("Lint Check") {
-      agent { docker { image "dgllib/dgl-ci-lint" } }
+      agent { 
+        docker {
+          label "linux-cpu-node"
+          image "dgllib/dgl-ci-lint" 
+        }
+      }
       steps {
         init_git()
         sh "bash tests/scripts/task_lint.sh"
@@ -119,7 +125,12 @@ pipeline {
     stage("Build") {
       parallel {
         stage("CPU Build") {
-          agent { docker { image "dgllib/dgl-ci-cpu" } }
+          agent { 
+            docker {
+              label "linux-cpu-node"
+              image "dgllib/dgl-ci-cpu:conda" 
+            }
+          }
           steps {
             build_dgl_linux("cpu")
           }
@@ -132,8 +143,9 @@ pipeline {
         stage("GPU Build") {
           agent {
             docker {
-              image "dgllib/dgl-ci-gpu"
-              args "--runtime nvidia"
+              label "linux-cpu-node"
+              image "dgllib/dgl-ci-gpu:conda"
+              args "-u root"
             }
           }
           steps {
@@ -165,7 +177,12 @@ pipeline {
     stage("Test") {
       parallel {
         stage("C++ CPU") {
-          agent { docker { image "dgllib/dgl-ci-cpu" } }
+          agent { 
+            docker { 
+              label "linux-cpu-node"
+              image "dgllib/dgl-ci-cpu:conda"
+            }
+          }
           steps {
             cpp_unit_test_linux()
           }
@@ -186,8 +203,54 @@ pipeline {
             }
           }
         }
+        stage("Tensorflow CPU") {
+          agent { 
+            docker {
+              label "linux-cpu-node"
+              image "dgllib/dgl-ci-cpu:conda" 
+            }
+          }
+          stages {
+            stage("Unit test") {
+              steps {
+                unit_test_linux("tensorflow", "cpu")
+              }
+            }
+          }
+          post {
+            always {
+              cleanWs disableDeferredWipeout: true, deleteDirs: true
+            }
+          }
+        }
+        stage("Tensorflow GPU") {
+          agent { 
+            docker { 
+              label "linux-gpu-node"
+              image "dgllib/dgl-ci-gpu:conda" 
+              args "--runtime nvidia"
+            }
+          }
+          stages {
+            stage("Unit test") {
+              steps {
+                unit_test_linux("tensorflow", "gpu")
+              }
+            }
+          }
+          post {
+            always {
+              cleanWs disableDeferredWipeout: true, deleteDirs: true
+            }
+          }
+        }
         stage("Torch CPU") {
-          agent { docker { image "dgllib/dgl-ci-cpu" } }
+          agent { 
+            docker {
+              label "linux-cpu-node"
+              image "dgllib/dgl-ci-cpu:conda" 
+            }
+          }
           stages {
             stage("Unit test") {
               steps {
@@ -234,7 +297,8 @@ pipeline {
         stage("Torch GPU") {
           agent {
             docker {
-              image "dgllib/dgl-ci-gpu"
+              label "linux-gpu-node"
+              image "dgllib/dgl-ci-gpu:conda"
               args "--runtime nvidia"
             }
           }
@@ -258,7 +322,12 @@ pipeline {
           }
         }
         stage("MXNet CPU") {
-          agent { docker { image "dgllib/dgl-ci-cpu" } }
+          agent { 
+            docker {
+              label "linux-cpu-node"
+              image "dgllib/dgl-ci-cpu:conda" 
+            }
+          }
           stages {
             stage("Unit test") {
               steps {
@@ -280,7 +349,8 @@ pipeline {
         stage("MXNet GPU") {
           agent {
             docker {
-              image "dgllib/dgl-ci-gpu"
+              label "linux-gpu-node" 
+              image "dgllib/dgl-ci-gpu:conda"
               args "--runtime nvidia"
             }
           }
@@ -303,7 +373,12 @@ pipeline {
     stage("App") {
       parallel {
         stage("Knowledge Graph CPU") {
-          agent { docker { image "dgllib/dgl-ci-cpu:torch-1.2.0" } }
+          agent { 
+            docker {
+              label "linux-cpu-node"
+              image "dgllib/dgl-ci-cpu:conda" 
+            }
+          }
           stages {
             stage("Torch test") {
               steps {
@@ -325,7 +400,8 @@ pipeline {
         stage("Knowledge Graph GPU") {
           agent {
             docker {
-              image "dgllib/dgl-ci-gpu:torch-1.2.0"
+              label "linux-gpu-node"
+              image "dgllib/dgl-ci-gpu:conda"
               args "--runtime nvidia"
             }
           }

README.md

@@ -18,7 +18,7 @@ All model examples can be found [here](https://github.com/dmlc/dgl/tree/master/e
 A summary of part of the model accuracy and training speed with the Pytorch backend (on Amazon EC2 p3.2x instance (w/ V100 GPU)), as compared with the best open-source implementations:
 
 | Model                                                            | Reported <br> Accuracy | DGL <br> Accuracy | Author's training speed (epoch time)                                          | DGL speed (epoch time) | Improvement |
-| -----                                                            | -----------------      | ------------      | ------------------------------------                                          | ---------------------- | ----------- |
+| ---------------------------------------------------------------- | ---------------------- | ----------------- | ----------------------------------------------------------------------------- | ---------------------- | ----------- |
 | [GCN](https://arxiv.org/abs/1609.02907)                          | 81.5%                  | 81.0%             | [0.0051s (TF)](https://github.com/tkipf/gcn)                                  | 0.0031s                | 1.64x       |
 | [GAT](https://arxiv.org/abs/1710.10903)                          | 83.0%                  | 83.9%             | [0.0982s (TF)](https://github.com/PetarV-/GAT)                                | 0.0113s                | 8.69x       |
 | [SGC](https://arxiv.org/abs/1902.07153)                          | 81.0%                  | 81.9%             | n/a                                                                           | 0.0008s                | n/a         |
@@ -28,6 +28,7 @@ A summary of part of the model accuracy and training speed with the Pytorch back
 | [JTNN](https://arxiv.org/abs/1802.04364)                         | 96.44%                 | 96.44%            | [1826s (Pytorch)](https://github.com/wengong-jin/icml18-jtnn)                 | 743s                   | 2.5x        |
 | [LGNN](https://arxiv.org/abs/1705.08415)                         | 94%                    | 94%               | n/a                                                                           | 1.45s                  | n/a         |
 | [DGMG](https://arxiv.org/pdf/1803.03324.pdf)                     | 84%                    | 90%               | n/a                                                                           | 238s                   | n/a         |
+| [GraphWriter](https://www.aclweb.org/anthology/N19-1238.pdf)     | 14.3(BLEU)             | 14.31(BLEU)       | [1970s (PyTorch)](https://github.com/rikdz/GraphWriter)                       | 1192s                  | 1.65x       |
 
 With the MXNet/Gluon backend , we scaled a graph of 50M nodes and 150M edges on a P3.8xlarge instance, 
 with 160s per epoch, on SSE ([Stochastic Steady-state Embedding](https://www.cc.gatech.edu/~hdai8/pdf/equilibrium_embedding.pdf)), 
@@ -69,16 +70,19 @@ conda install -c dglteam dgl           # cpu version
 conda install -c dglteam dgl-cuda9.0   # CUDA 9.0
 conda install -c dglteam dgl-cuda9.2   # CUDA 9.2
 conda install -c dglteam dgl-cuda10.0  # CUDA 10.0
+conda install -c dglteam dgl-cuda10.1  # CUDA 10.1
 ```
 
 ### Using pip
 
-```
-pip install dgl       # cpu version
-pip install dgl-cu90  # CUDA 9.0
-pip install dgl-cu92  # CUDA 9.2
-pip install dgl-cu100 # CUDA 10.0
-```
+
+|           | Latest Nightly Build Version  | Stable Version          |
+|-----------|-------------------------------|-------------------------|
+| CPU       | `pip install --pre dgl`       | `pip install dgl`       |
+| CUDA 9.0  | `pip install --pre dgl-cu90`  | `pip install dgl-cu90`  |
+| CUDA 9.2  | `pip install --pre dgl-cu92`  | `pip install dgl-cu92`  |
+| CUDA 10.0 | `pip install --pre dgl-cu100` | `pip install dgl-cu100` |
+| CUDA 10.1 | `pip install --pre dgl-cu101` | `pip install dgl-cu101` |
 
 ### From source
 
@@ -188,7 +192,7 @@ If you use DGL in a scientific publication, we would appreciate citations to the
 @article{wang2019dgl,
     title={Deep Graph Library: Towards Efficient and Scalable Deep Learning on Graphs},
     url={https://arxiv.org/abs/1909.01315},
-    author={{Wang, Minjie and Yu, Lingfan and Zheng, Da and Gan, Quan and Gai, Yu and Ye, Zihao and Li, Mufei and Zhou, Jinjing and Huang, Qi and Ma, Chao and Huang, Ziyue and Guo, Qipeng and Zhang, Hao and Lin, Haibin and Zhao, Junbo and Li, Jinyang and Smola, Alexander J and Zhang, Zheng},
+    author={Wang, Minjie and Yu, Lingfan and Zheng, Da and Gan, Quan and Gai, Yu and Ye, Zihao and Li, Mufei and Zhou, Jinjing and Huang, Qi and Ma, Chao and Huang, Ziyue and Guo, Qipeng and Zhang, Hao and Lin, Haibin and Zhao, Junbo and Li, Jinyang and Smola, Alexander J and Zhang, Zheng},
     journal={ICLR Workshop on Representation Learning on Graphs and Manifolds},
     year={2019}
 }

apps/kg/README.md

@@ -15,11 +15,12 @@ takes a couple of hours on Freebase, which has hundreds of millions of edges.
 
 DGL-KE includes the following knowledge graph embedding models:
 
-- TransE
+- TransE (TransE_l1 with L1 distance and TransE_l2 with L2 distance)
 - DistMult
 - ComplEx
 - RESCAL
 - TransR
+- RotatE
 
 It will add other popular models in the future.
 
@@ -61,39 +62,43 @@ The speed is measured with 16 CPU cores and one Nvidia V100 GPU.
 
 The speed on FB15k
 
-|  Models | TransE | DistMult | ComplEx | RESCAL | TransR |
-|---------|--------|----------|---------|--------|--------|
-|MAX_STEPS| 20000  | 100000   | 100000  | 30000  | 100000 |
-|TIME     | 411s   | 690s     | 806s    | 1800s  | 7627s  |
+|  Models | TransE_l1 | TransE_l2 | DistMult | ComplEx | RESCAL | TransR | RotatE |
+|---------|-----------|-----------|----------|---------|--------|--------|--------|
+|MAX_STEPS| 20000     | 30000     |100000    | 100000  | 30000  | 100000 | 100000 |
+|TIME     | 411s      | 329s      |690s      | 806s    | 1800s  | 7627s  | 4327s  |
 
 The accuracy on FB15k
 
-|  Models  |  MR   |  MRR  | HITS@1 | HITS@3 | HITS@10 |
-|----------|-------|-------|--------|--------|---------|
-| TransE   | 69.12 | 0.656 | 0.567  | 0.718  | 0.802   |
-| DistMult | 43.35 | 0.783 | 0.713  | 0.837  | 0.897   |
-| ComplEx  | 51.99 | 0.785 | 0.720  | 0.832  | 0.889   |
-| RESCAL   | 130.89| 0.668 | 0.597  | 0.720  | 0.800   |
-| TransR   | 138.7 | 0.501 | 0.274  | 0.704  | 0.801   |
+|  Models   |  MR   |  MRR  | HITS@1 | HITS@3 | HITS@10 |
+|-----------|-------|-------|--------|--------|---------|
+| TransE_l1 | 69.12 | 0.656 | 0.567  | 0.718  | 0.802   |
+| TransE_l2 | 35.86 | 0.570 | 0.400  | 0.708  | 0.834   |
+| DistMult  | 43.35 | 0.783 | 0.713  | 0.837  | 0.897   |
+| ComplEx   | 51.99 | 0.785 | 0.720  | 0.832  | 0.889   |
+| RESCAL    | 130.89| 0.668 | 0.597  | 0.720  | 0.800   |
+| TransR    | 138.7 | 0.501 | 0.274  | 0.704  | 0.801   |
+| RotatE    | 39.6  | 0.725 | 0.628  | 0.802  | 0.875   |
 
 In comparison, GraphVite uses 4 GPUs and takes 14 minutes. Thus, DGL-KE trains TransE on FB15k twice as fast as GraphVite while using much few resources. More performance information on GraphVite can be found [here](https://github.com/DeepGraphLearning/graphvite).
 
 The speed on wn18
 
-|  Models | TransE | DistMult | ComplEx | RESCAL | TransR |
-|---------|--------|----------|---------|--------|--------|
-|MAX_STEPS| 40000  | 10000    | 20000   | 20000  | 20000  |
-|TIME     | 719s   | 126s     | 266s    | 333s   | 1547s  |
+|  Models | TransE_l1 | TransE_l2 | DistMult | ComplEx | RESCAL | TransR | RotatE |
+|---------|-----------|-----------|----------|---------|--------|--------|--------|
+|MAX_STEPS| 40000     | 20000     | 10000    | 20000   | 20000  | 20000  | 20000  |
+|TIME     | 719s      | 254s      | 126s     | 266s    | 333s   | 1547s  | 786s   |
 
 The accuracy on wn18
 
-|  Models  |  MR    |  MRR  | HITS@1 | HITS@3 | HITS@10 |
-|----------|--------|-------|--------|--------|---------|
-| TransE   | 321.35 | 0.760 | 0.652  | 0.850  | 0.940   |
-| DistMult | 271.09 | 0.769 | 0.639  | 0.892  | 0.949   |
-| ComplEx  | 276.37 | 0.935 | 0.916  | 0.950  | 0.960   |
-| RESCAL   | 579.54 | 0.846 | 0.791  | 0.898  | 0.931   |
-| TransR   | 615.56 | 0.606 | 0.378  | 0.826  | 0.890   |
+|  Models   |  MR    |  MRR  | HITS@1 | HITS@3 | HITS@10 |
+|-----------|--------|-------|--------|--------|---------|
+| TransE_l1 | 321.35 | 0.760 | 0.652  | 0.850  | 0.940   |
+| TransE_l2 | 181.57 | 0.570 | 0.322  | 0.802  | 0.944   |
+| DistMult  | 271.09 | 0.769 | 0.639  | 0.892  | 0.949   |
+| ComplEx   | 276.37 | 0.935 | 0.916  | 0.950  | 0.960   |
+| RESCAL    | 579.54 | 0.846 | 0.791  | 0.898  | 0.931   |
+| TransR    | 615.56 | 0.606 | 0.378  | 0.826  | 0.890   |
+| RotatE    | 367.64 | 0.931 | 0.924  | 0.935  | 0.944   | 
 
 The speed on Freebase
 

apps/kg/config/best_config.sh

@@ -10,10 +10,14 @@ DGLBACKEND=pytorch python3 train.py --model ComplEx --dataset FB15k --batch_size
     --neg_sample_size 256 --hidden_dim 2000 --gamma 500.0 --lr 0.2 --max_step 100000 \
     --batch_size_eval 16 --gpu 0 --valid --test -adv
 
-DGLBACKEND=pytorch python3 train.py --model TransE --dataset FB15k --batch_size 1024 \
+DGLBACKEND=pytorch python3 train.py --model TransE_l1 --dataset FB15k --batch_size 1024 \
     --neg_sample_size 256 --hidden_dim 2000 --gamma 24.0 --lr 0.01 --max_step 20000 \
     --batch_size_eval 16 --gpu 0 --valid --test -adv
 
+DGLBACKEND=pytorch python3 train.py --model TransE_l2 --dataset FB15k --batch_size 1024 \
+    --neg_sample_size 256 --hidden_dim 2000 --gamma 12.0 --lr 0.1 --max_step 30000 \
+    --batch_size_eval 16 --gpu 0 --valid --test -adv --regularization_coef=2e-7 
+
 DGLBACKEND=pytorch python3 train.py --model RESCAL --dataset FB15k --batch_size 1024 \
     --neg_sample_size 256 --hidden_dim 500 --gamma 24.0 --lr 0.03 --max_step 30000 \
     --batch_size_eval 16 --gpu 0 --valid --test -adv
@@ -22,13 +26,21 @@ DGLBACKEND=pytorch python3 train.py --model TransR --dataset FB15k --batch_size
     --neg_sample_size 256 --hidden_dim 500 --gamma 24.0 --lr 0.01 --max_step 30000 \
     --batch_size_eval 16 --gpu 0 --valid --test -adv
 
+DGLBACKEND=pytorch python3 train.py --model RotatE --dataset FB15k --batch_size 1024 \
+    --neg_sample_size 256 --hidden_dim 400 --gamma 12.0 --lr 0.01 --max_step 30000 \
+    --batch_size_eval 16 --gpu 0 --valid --test -adv -de --regularization_coef=1e-4
+
 # for wn18
 
-DGLBACKEND=pytorch python3 train.py --model TransE --dataset wn18 --batch_size 1024 \
+DGLBACKEND=pytorch python3 train.py --model TransE_l1 --dataset wn18 --batch_size 1024 \
     --neg_sample_size 512 --hidden_dim 500 --gamma 12.0 --adversarial_temperature 0.5 \
     --lr 0.01 --max_step 40000 --batch_size_eval 16 --gpu 0 --valid --test -adv \
     --regularization_coef 0.00001
 
+DGLBACKEND=pytorch python3 train.py --model TransE_l2 --dataset wn18 --batch_size 1024 \
+    --neg_sample_size 512 --hidden_dim 500 --gamma 6.0 --lr 0.1 --max_step 20000 \
+    --batch_size_eval 16 --gpu 0 --valid --test -adv --regularization_coef 0.0000001
+
 DGLBACKEND=pytorch python3 train.py --model DistMult --dataset wn18 --batch_size 1024 \
     --neg_sample_size 1024 --hidden_dim 1000 --gamma 200.0 --lr 0.1 --max_step 10000 \
     --batch_size_eval 16 --gpu 0 --valid --test -adv --regularization_coef 0.00001
@@ -45,6 +57,10 @@ DGLBACKEND=pytorch python3 train.py --model TransR --dataset wn18 --batch_size 1
     --neg_sample_size 256 --hidden_dim 500 --gamma 16.0 --lr 0.1 --max_step 30000 \
     --batch_size_eval 16 --gpu 0 --valid --test -adv
 
+DGLBACKEND=pytorch python3 train.py --model RotatE --dataset wn18 --batch_size 1024 \
+    --neg_sample_size 256 --hidden_dim 400 --gamma 12.0 --lr 0.02 --max_step 20000 \
+    --batch_size_eval 16 --gpu 0 --valid --test -adv -de
+
 # for Freebase
 
 DGLBACKEND=pytorch python3 train.py --model ComplEx --dataset Freebase --batch_size 1024 \