diff --git a/README.md b/README.md
index 63c55800c..2ac3cd6df 100644
--- a/README.md
+++ b/README.md
@@ -73,7 +73,7 @@ The StellarGraph library can be used to solve tasks using graph-structured data,
 - Representation learning for nodes and edges, to be used for visualisation and various downstream machine learning tasks;
 - Classification and attribute inference of nodes or edges;
 - Link prediction;
-- Interpretation of node classification through calculated importances of edges and neighbours for selected nodes [7].
+- Interpretation of node classification through calculated importances of edges and neighbours for selected nodes [8].
 
 We provide [examples](https://github.com/stellargraph/stellargraph/tree/master/demos/) of using `StellarGraph` to solve such tasks using several real-world datasets.
 
@@ -130,7 +130,7 @@ can be downloaded and installed from [python.org](https://python.org/). Alternat
 environment, available from [anaconda.com](https://www.anaconda.com/download/).
 
 *Note*: while the library works on Python 3.7 it is based on Keras which does not officially support Python 3.7.
-Therefore, there may be unforseen bugs and you there are many warnings from the Python libraries that 
+Therefore, there may be unforseen bugs and you there are many warnings from the Python libraries that
 StellarGraph depends upon.
 
 <!--
@@ -172,7 +172,7 @@ pip install .[demos]
 
 * [stellargraph/stellargraph](https://hub.docker.com/r/stellargraph/stellargraph): Docker image with `stellargraph` installed.
 
-Images can be pulled via `docker pull stellargraph/stellargraph` 
+Images can be pulled via `docker pull stellargraph/stellargraph`
 
 
 ## Running the examples
@@ -193,13 +193,16 @@ The StellarGraph library currently includes the following algorithms for graph m
   The current implementation supports mean aggregation of neighbour nodes,
   taking into account their types and the types of links between them.
 
-* The Graph ATtention Network (GAT) [4]
+* attri2vec [4]
+  - Supports node representation learning, node classification, and out-of-sample node link prediction for homogeneous graphs with node attributes.
+
+* The Graph ATtention Network (GAT) [5]
   - The GAT algorithm supports representation learning and node classification for homogeneous graphs. There are versions of the graph attention layer that support both sparse and dense adjacency matrices.
 
-* Graph Convolutional Network (GCN) [5]
+* Graph Convolutional Network (GCN) [6]
   - The GCN algorithm supports representation learning and node classification for homogeneous graphs. There are versions of the graph convolutional layer that support both sparse and dense adjacency matrices.
 
-* Simplified Graph Convolutional network (SGC) [6]
+* Simplified Graph Convolutional network (SGC) [7]
   - The SGC network algorithm supports representation learning and node classification for homogeneous graphs. It is an extension of the GCN algorithm that smooths the graph to bring in more distant neighbours of nodes without using multiple layers.
 
 * Node2Vec [2]
@@ -262,14 +265,17 @@ Neural Information Processing Systems (NIPS), 2017. ([link](https://arxiv.org/ab
 ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 135–144, 2017
 ([link](https://ericdongyx.github.io/metapath2vec/m2v.html))
 
-4. Graph Attention Networks. P. Velickovic et al.
+4. Attributed Network Embedding via Subspace Discovery. D. Zhang, Y. Jie, X. Zhu and C. Zhang, arXiv:1901.04095,
+[cs.SI], 2019. ([link](https://arxiv.org/abs/1901.04095))
+
+5. Graph Attention Networks. P. Velickovic et al.
 International Conference on Learning Representations (ICLR) 2018 ([link](https://arxiv.org/abs/1710.10903))
 
-5. Graph Convolutional Networks (GCN): Semi-Supervised Classification with Graph Convolutional Networks. Thomas N. Kipf, Max Welling.
+6. Graph Convolutional Networks (GCN): Semi-Supervised Classification with Graph Convolutional Networks. Thomas N. Kipf, Max Welling.
 International Conference on Learning Representations (ICLR), 2017
 ([link](https://github.com/tkipf/gcn))
 
-6. Simplifying Graph Convolutional Networks. F. Wu, T. Zhang, A. H. de Souza, C. Fifty, T. Yu, and K. Q. Weinberger. 
+7. Simplifying Graph Convolutional Networks. F. Wu, T. Zhang, A. H. de Souza, C. Fifty, T. Yu, and K. Q. Weinberger.
 International Conference on Machine Learning (ICML), 2019. ([link](https://arxiv.org/abs/1902.07153))
 
-7. Adversarial Examples on Graph Data: Deep Insights into Attack and Defense. H. Wu, C. Wang, Y. Tyshetskiy, A. Docherty, K. Lu, and L. Zhu. IJCAI 2019. ([link](https://arxiv.org/abs/1903.01610))
+8. Adversarial Examples on Graph Data: Deep Insights into Attack and Defense. H. Wu, C. Wang, Y. Tyshetskiy, A. Docherty, K. Lu, and L. Zhu. IJCAI 2019. ([link](https://arxiv.org/abs/1903.01610))
diff --git a/demos/README.md b/demos/README.md
index 970549801..a2311696e 100644
--- a/demos/README.md
+++ b/demos/README.md
@@ -7,10 +7,11 @@ examples demonstrate using the `StellarGraph` library to build machine learning
 workflows on both homogeneous and heterogeneous networks.
 
 Each folder contains one or more examples of using the StellarGraph implementations of the
-state-of-the-art algorithms, GraphSAGE [3], HinSAGE, GCN [5], GAT [6], Node2Vec [1], and Metapath2Vec [2]. 
-GraphSAGE, HinSAGE, and GAT are variants of Graph Convolutional Neural networks [5]. Node2Vec and
+state-of-the-art algorithms, attri2vec [4], GraphSAGE [3], HinSAGE, GCN [6], GAT [7], Node2Vec [1], and Metapath2Vec [2].
+GraphSAGE, HinSAGE, and GAT are variants of Graph Convolutional Neural networks [6]. Node2Vec and
 Metapath2Vec are methods based on graph random walks and representation learning using the
-Word2Vec [4] algorithm.
+Word2Vec [5] algorithm. attri2vec[4] is also based on graph random walks, and learns node
+representations by performing a mapping on node attributes.
 
 The examples folder structure is shown below.
 
@@ -30,8 +31,8 @@ The examples folder structure is shown below.
 * [`/ensembles`](https://github.com/stellargraph/stellargraph/tree/master/demos/ensembles)
 
     Examples of using ensembles of graph convolutional neural networks, e.g., GraphSAGE, GCN, HinSAGE, etc., for
-    node classification and link prediction. Model ensembles usually yield better predictions than single models, 
-    while also providing estimates of prediction uncertainty as a bonus. 
+    node classification and link prediction. Model ensembles usually yield better predictions than single models,
+    while also providing estimates of prediction uncertainty as a bonus.
 
 * [`/calibration`](https://github.com/stellargraph/stellargraph/tree/master/demos/calibration)
 
@@ -49,24 +50,27 @@ The examples folder structure is shown below.
 
 ## References
 
-1. Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference on 
+1. Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference on
 Knowledge Discovery and Data Mining (KDD), 2016. ([link](https://snap.stanford.edu/node2vec/))
 
-2. Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and 
+2. Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and
 Ananthram Swami. ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 135–144, 2017
 ([link](https://ericdongyx.github.io/metapath2vec/m2v.html))
 
-3. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216 
+3. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216
 [cs.SI], 2017. ([link](http://snap.stanford.edu/graphsage/))
 
-4. Distributed representations of words and phrases and their compositionality. T. Mikolov, 
+4. Attributed Network Embedding via Subspace Discovery. D. Zhang, Y. Jie, X. Zhu and C. Zhang, arXiv:1901.04095,
+[cs.SI], 2019. ([link](https://arxiv.org/abs/1901.04095))
+
+5. Distributed representations of words and phrases and their compositionality. T. Mikolov,
 I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. In Advances in Neural Information Processing
  Systems (NIPS), pp. 3111-3119, 2013. ([link](https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf))
 
-5. Semi-Supervised Classification with Graph Convolutional Networks. T. Kipf, M. Welling. 
+6. Semi-Supervised Classification with Graph Convolutional Networks. T. Kipf, M. Welling.
 ICLR 2017. arXiv:1609.02907 ([link](https://arxiv.org/abs/1609.02907))
 
-6. Graph Attention Networks. P. Velickovic et al. ICLR 2018 ([link](https://arxiv.org/abs/1710.10903))
+7. Graph Attention Networks. P. Velickovic et al. ICLR 2018 ([link](https://arxiv.org/abs/1710.10903))
 
-7. On Calibration of Modern Neural Networks. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger. 
+8. On Calibration of Modern Neural Networks. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger.
 ICML 2017. ([link](https://geoffpleiss.com/nn_calibration))
diff --git a/demos/embeddings/README.md b/demos/embeddings/README.md
index db2c667f7..688ec38b5 100644
--- a/demos/embeddings/README.md
+++ b/demos/embeddings/README.md
@@ -1,34 +1,39 @@
 ## Representation Learning Examples
 
-This folder contains three [Jupyter](http://jupyter.org/) python notebooks demonstrating the use of unsupervised graph representation learning methods implemented in the `stellargraph` library for homogeneous and hetrogenous graphs with or without node features. The original works are referenced below. 
+This folder contains four [Jupyter](http://jupyter.org/) python notebooks demonstrating the use of unsupervised graph representation learning methods implemented in the `stellargraph` library for homogeneous and heterogenous graphs with or without node features. The original works are referenced below.
 
-**Node2Vec** and **Metapath2Vec** notebooks demonstrate the combined use of `stellargraph` and `Gensim` [4] libraries for representation learning on homogeneous and heterogeneous graphs. 
+**Node2Vec** and **Metapath2Vec** notebooks demonstrate the combined use of `stellargraph` and `Gensim` [4] libraries for representation learning on homogeneous and heterogeneous graphs.
 **Unsupervised GraphSAGE** notebook demonstrates the use of `Stellargraph` library's GraphSAGE implementation for unsupervised learning of node embeddings for homogeneous graphs with node features.
+**attri2vec** notebook demonstrates the implementation of attri2vec with the `Stellargraph` library for unsupervised inductive learning of node embeddings for homogeneous graphs with node features, and the evaluation for its ability to infer the representations of out-of-sample nodes with the out-of-sample node link prediction task.   
 
 The notebooks demonstrate the following algorithms.
-- `stellargraph-node2vec.ipynb` The **Node2Vec** algorithm [1] for representation learning on homogeneous graphs
+- `stellargraph-node2vec.ipynb` The **Node2Vec** algorithm [1] for representation learning on homogeneous graphs.
 - `stellargraph-metapath2vec.ipynb` The **Metapath2Vec** algorithm [2] for representation learning on heterogeneous graphs.
 - `embeddings-unsupervised-graphsage-cora.ipynb` The **Unsupervised GraphSAGE** algorithm [5] for representation learning on homogeneous graphs with node features.
+- `stellargraph-attri2vec-citeseer.ipynb` The **attri2vec** algorithm [6] for representation learning on the homogeneous graph with node features.
 
-All examples demonstrate how to calculate embedding vectors for a graph's nodes in just a few lines of Python code. 
+All examples demonstrate how to calculate embedding vectors for a graph's nodes in just a few lines of Python code.
 The learned node representations can be used in numerous downstream tasks such as node attribute inference, link
 prediction, and community detection.
 
 
 ## References
 
-**1.** Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference 
+**1.** Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference
 on Knowledge Discovery and Data Mining (KDD), 2016. ([link](https://snap.stanford.edu/node2vec/))
 
-**2.**  Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and 
-Ananthram Swami. ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 135–144, 2017. 
+**2.**  Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and
+Ananthram Swami. ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 135–144, 2017.
 ([link](https://ericdongyx.github.io/papers/KDD17-dong-chawla-swami-metapath2vec.pdf))
 
-**3.** Distributed representations of words and phrases and their compositionality. T. Mikolov, I. Sutskever, K. Chen, 
-G. S. Corrado, and J. Dean.  In Advances in Neural Information Processing Systems (NIPS), pp. 3111-3119, 2013. 
+**3.** Distributed representations of words and phrases and their compositionality. T. Mikolov, I. Sutskever, K. Chen,
+G. S. Corrado, and J. Dean.  In Advances in Neural Information Processing Systems (NIPS), pp. 3111-3119, 2013.
 ([link](https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf))
 
 **4.** Gensim: Topic modelling for humans. ([link](https://radimrehurek.com/gensim/))
 
 **5.** Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216
 [cs.SI], 2017. ([link](http://snap.stanford.edu/graphsage/))
+
+**6.** Attributed Network Embedding via Subspace Discovery. D. Zhang, Y. Jie, X. Zhu and C. Zhang, arXiv:1901.04095,
+[cs.SI], 2019. ([link](https://arxiv.org/abs/1901.04095))
diff --git a/demos/embeddings/stellargraph-attri2vec-citeseer.ipynb b/demos/embeddings/stellargraph-attri2vec-citeseer.ipynb
new file mode 100644
index 000000000..146b2d9b5
--- /dev/null
+++ b/demos/embeddings/stellargraph-attri2vec-citeseer.ipynb
@@ -0,0 +1,690 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Node Representation Learning with attri2vec on Citeseer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is the python implementation of the attri2vec algorithm outlined in paper ***[Attributed Network Embedding Via Subspace Discovery](https://arxiv.org/abs/1901.04095)*** D. Zhang, Y. Jie, X. Zhu and C. Zhang, arXiv:1901.04095, [cs.SI], 2019. The implementation uses the stellargraph libraries.\n",
+    "\n",
+    "\n",
+    "## attri2vec\n",
+    "\n",
+    "attri2vec learns node representations by performing a linear/non-linear mapping on node content attributes. To make the learned node representations respect structural similarity, [`DeepWalk`](https://dl.acm.org/citation.cfm?id=2623732)/[`node2vec`](https://snap.stanford.edu/node2vec) learning mechanism is used to make nodes sharing similar random walk context nodes represented closely in the subspace, which is achieved by maximizing the occurrence probability of context nodes conditioned on the representation of the target nodes. The probability is modelled by Softmax and negative sampling is used to speed up its calculation. This makes attri2vec equivalent to predict whether a node occurs in the given target node's context in random walks with the representation of the target node, by minimizing the cross-entropy loss. \n",
+    "\n",
+    "In implementation, node embeddings are learnt by solving a simple classification task: given a large set of \"positive\" `(target, context)` node pairs generated from random walks performed on the graph (i.e., node pairs that co-occur within a certain context window in random walks), and an equally large set of \"negative\" node pairs that are randomly selected from the graph according to a certain distribution, learn a binary classifier that predicts whether arbitrary node pairs are likely to co-occur in a random walk performed on the graph. Through learning this simple binary node-pair-classification task, the model automatically learns an inductive mapping from attributes of nodes to node embeddings in a low-dimensional vector space, which preserves structural and feature similarities of the nodes. \n",
+    "\n",
+    "To train the attri2vec model, we first construct a training set of nodes, which is composed of an equal number of positive and negative `(target, context)` pairs from the graph. The positive `(target, context)` pairs are the node pairs co-occurring on random walks over the graph whereas the negative node pairs are the sampled randomly from the global node degree distribution of the graph. In attri2vec, each node is attached with two kinds of embeddings: 1) the inductive 'input embedding', i.e, the objective embedding, obtained by perform a linear/non-linear transformation on node content features, and 2) 'output embedding', i.e., the parameter vector used to predict its occurrence as a context node, obtained by looking up a parameter table. Given a `(target, context)` pair, attri2vec outputs a predictive value to indicate whether it is positive or negative, which is obtained by performing the dot product of the 'input embedding' of the target node and the 'output embedding' of the context node, followed by a sigmoid activation. \n",
+    "\n",
+    "The entire model is trained end-to-end by minimizing the binary cross-entropy loss function with regards to predicted node pair labels and true node pair labels, using stochastic gradient descent (SGD) updates of the model parameters, with minibatches of 'training' node pairs generated on demand and fed into the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import random\n",
+    "\n",
+    "import stellargraph as sg\n",
+    "from stellargraph.data import UnsupervisedSampler\n",
+    "from stellargraph.mapper import Attri2VecLinkGenerator, Attri2VecNodeGenerator\n",
+    "from stellargraph.layer import Attri2Vec, link_classification\n",
+    "\n",
+    "from tensorflow import keras\n",
+    "\n",
+    "from pandas.core.indexes.base import Index\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.manifold import TSNE\n",
+    "from sklearn.decomposition import PCA\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LogisticRegressionCV\n",
+    "from sklearn.metrics import accuracy_score"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The dataset is the citation network Citeseer.\n",
+    "\n",
+    "It can be downloaded by clicking [here](https://linqs-data.soe.ucsc.edu/public/lbc/citesser.tgz)\n",
+    "\n",
+    "The following is the description of the dataset from the publisher,\n",
+    "> The CiteSeer dataset consists of 3312 scientific publications classified into one of six classes. The citation network consists of 4732 links. Each publication in the dataset is described by a 0/1-valued word vector indicating the absence/presence of the corresponding word from the dictionary. The dictionary consists of 3703 unique words. The README file in the dataset provides more details.\n",
+    "\n",
+    "Download and unzip the citeseer.tgz file to a location on your computer. \n",
+    "\n",
+    "We assume that the dataset is stored in the directory\n",
+    "\n",
+    "`~/data/citeseer/`\n",
+    "\n",
+    "where the files `citeseer.cites` and `citeseer.content` can be located.\n",
+    "\n",
+    "We are going to load the data into a networkx object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_dir = \"~/data/citeseer\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load edges in order 'cited-paper' <- 'citing-paper'."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "citeseer_location = os.path.expanduser(os.path.join(data_dir, \"citeseer.cites\"))\n",
+    "g_nx = nx.read_edgelist(path=citeseer_location, create_using=nx.DiGraph()).reverse()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Convert the graph to undirected graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g_nx = g_nx.to_undirected()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load the node attribute data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3057: DtypeWarning: Columns (0) have mixed types. Specify dtype option on import or set low_memory=False.\n",
+      "  interactivity=interactivity, compiler=compiler, result=result)\n"
+     ]
+    }
+   ],
+   "source": [
+    "citeseer_data_location = os.path.expanduser(os.path.join(data_dir, \"citeseer.content\"))\n",
+    "attr_names = [\"w_{}\".format(ii) for ii in range(3703)]\n",
+    "node_column_names =  attr_names + [\"subject\"]\n",
+    "node_attr = pd.read_csv(citeseer_data_location, sep='\\t', header=None, names=node_column_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Change the type of the indexes of node_attr to str."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_attr.index = Index(list(map(str, list(node_attr.index))))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The original graph contains some nodes with no attributes. We remove them here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g_nx = g_nx.subgraph(list(node_attr.index))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Select the largest connected component. For clarity we ignore isolated nodes and subgraphs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Largest subgraph statistics: 2110 nodes, 3720 edges\n"
+     ]
+    }
+   ],
+   "source": [
+    "g_nx_ccs = (g_nx.subgraph(c).copy() for c in nx.connected_components(g_nx))\n",
+    "g_nx = max(g_nx_ccs, key=len)\n",
+    "print(\"Largest subgraph statistics: {} nodes, {} edges\".format(\n",
+    "    g_nx.number_of_nodes(), g_nx.number_of_edges()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify node types."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nx.set_node_attributes(g_nx, \"paper\", \"label\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the ids of the nodes in the selected largest connected component. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_ids = sorted(list(g_nx.nodes))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get node features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_features = node_attr[attr_names].reindex(node_ids)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create the Stellargraph with node features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = sg.StellarGraph(g_nx, node_features=node_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "StellarGraph: Undirected multigraph\n",
+      " Nodes: 2110, Edges: 3720\n",
+      "\n",
+      " Node types:\n",
+      "  paper: [2110]\n",
+      "    Edge types: paper-default->paper\n",
+      "\n",
+      " Edge types:\n",
+      "    paper-default->paper: [3720]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(G.info())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train attri2vec on Citeseer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify the other optional parameter values: root nodes, the number of walks to take per node, the length of each walk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nodes = list(G.nodes())\n",
+    "number_of_walks = 4\n",
+    "length = 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create the UnsupervisedSampler instance with the relevant parameters passed to it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "unsupervised_samples = UnsupervisedSampler(G, nodes=nodes, length=length, number_of_walks=number_of_walks)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Set the batch size and the number of epochs. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 50\n",
+    "epochs = 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define an attri2vec training generator, which generates a batch of (feature of target node, index of context node, label of node pair) pairs per iteration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running Attri2VecLinkGenerator with an estimated 1688 batches generated on the fly per epoch.\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_gen = Attri2VecLinkGenerator(G, batch_size).flow(unsupervised_samples)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Building the model: a 1-hidden-layer node representation ('input embedding') of the `target` node and the parameter vector ('output embedding') for predicting the existence of `context node` for each `(target context)` pair, with a link classification layer performed on the dot product of the 'input embedding' of the `target` node and the 'output embedding' of the `context` node.\n",
+    "\n",
+    "Attri2Vec part of the model, with a 128-dimenssion hidden layer, no bias term and no normalization. (Normalization can be set to 'l2'). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "layer_sizes = [128]\n",
+    "attri2vec = Attri2Vec(\n",
+    "    layer_sizes=layer_sizes, generator=train_gen, bias=False, normalize=None\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: Logging before flag parsing goes to stderr.\n",
+      "W1001 15:58:33.015388 140735704433600 deprecation.py:506] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
+      "W1001 15:58:33.042335 140735704433600 deprecation.py:506] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/keras/initializers.py:119: calling RandomUniform.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Build the model and expose input and output sockets of attri2vec, for node pair inputs:\n",
+    "x_inp, x_out = attri2vec.build()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Use the link_classification function to generate the prediction, with the 'ip' edge embedding generation method and the 'sigmoid' activation, which actually performs the dot product of the 'input embedding' of the target node and the 'output embedding' of the context node followed by a sigmoid activation. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n"
+     ]
+    }
+   ],
+   "source": [
+    "prediction = link_classification(\n",
+    "    output_dim=1, output_act=\"sigmoid\", edge_embedding_method='ip'\n",
+    ")(x_out)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Stack the Attri2Vec encoder and prediction layer into a Keras model, and specify the loss."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = keras.Model(inputs=x_inp, outputs=prediction)\n",
+    "\n",
+    "model.compile(\n",
+    "    optimizer=keras.optimizers.Adam(lr=1e-3),\n",
+    "    loss=keras.losses.binary_crossentropy,\n",
+    "    metrics=[keras.metrics.binary_accuracy],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Train the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "W1001 15:58:33.300551 140735704433600 deprecation.py:323] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1688/1688 [==============================] - 12s 7ms/step - loss: 0.6825 - binary_accuracy: 0.5534\n",
+      "Epoch 2/4\n",
+      "1688/1688 [==============================] - 11s 7ms/step - loss: 0.5160 - binary_accuracy: 0.7534\n",
+      "Epoch 3/4\n",
+      "1688/1688 [==============================] - 11s 6ms/step - loss: 0.3368 - binary_accuracy: 0.8759\n",
+      "Epoch 4/4\n",
+      "1688/1688 [==============================] - 11s 7ms/step - loss: 0.2475 - binary_accuracy: 0.9150\n"
+     ]
+    }
+   ],
+   "source": [
+    "history = model.fit_generator(\n",
+    "    train_gen,\n",
+    "    epochs=epochs,\n",
+    "    verbose=1,\n",
+    "    use_multiprocessing=False,\n",
+    "    workers=1,\n",
+    "    shuffle=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##  Visualise Node Embeddings"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Build the node based model for predicting node representations from node content attributes with the learned parameters. Below a Keras model is constructed, with x_inp[0] as input and x_out[0] as output. Note that this model's weights are the same as those of the corresponding node encoder in the previously trained node pair classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_inp_src = x_inp[0]\n",
+    "x_out_src = x_out[0]\n",
+    "embedding_model = keras.Model(inputs=x_inp_src, outputs=x_out_src)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the node embeddings by applying the learned mapping function to node content features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "43/43 [==============================] - 0s 4ms/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "node_gen = Attri2VecNodeGenerator(G, batch_size).flow(node_ids)\n",
+    "node_embeddings = embedding_model.predict_generator(node_gen, workers=1, verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get node subjects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_targets = [ node_attr[\"subject\"][node_id] for node_id in node_ids ]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Transform the embeddings to 2d space for visualisation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transform = TSNE # PCA\n",
+    "\n",
+    "trans = transform(n_components=2)\n",
+    "node_embeddings_2d = trans.fit_transform(node_embeddings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# draw the embedding points, coloring them by the target label (paper subject)\n",
+    "alpha = 0.7\n",
+    "label_map = { l: i for i, l in enumerate(np.unique(node_targets)) }\n",
+    "node_colours = [ label_map[target] for target in node_targets ]\n",
+    "\n",
+    "plt.figure(figsize=(7,7))\n",
+    "plt.axes().set(aspect=\"equal\")\n",
+    "plt.scatter(node_embeddings_2d[:,0], \n",
+    "            node_embeddings_2d[:,1], \n",
+    "            c=node_colours, cmap=\"jet\", alpha=alpha)\n",
+    "plt.title('{} visualization of node embeddings'.format(transform.__name__))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Downstream Task"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The node representations learned by attri2vec can be used as features for downstream tasks, such as node classification, community detection, and link prediction. As attri2vec inductively learns a mapping function from node content features to the target embeddings, it has the ability to infer the representations for out-of-sample nodes, which can be used to predict the labels or links of out-of-sample nodes."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/demos/link-prediction/README.md b/demos/link-prediction/README.md
index b639e6515..9b8467077 100644
--- a/demos/link-prediction/README.md
+++ b/demos/link-prediction/README.md
@@ -6,10 +6,11 @@ examples demonstrate using the `StellarGraph` library to build machine learning
 workflows on both homogeneous and heterogeneous networks.
 
 Each folder contains one or more examples of using the StellarGraph implementations of the
-state-of-the-art algorithms, GraphSAGE [3], HinSAGE, GCN [5], GAT [6], Node2Vec [1], and Metapath2Vec [2]. 
-GraphSAGE, HinSAGE, and GAT are variants of Graph Convolutional Neural networks [5]. Node2Vec and
+state-of-the-art algorithms, attri2vec [4], GraphSAGE [3], HinSAGE, GCN [6], GAT [7], Node2Vec [1], and Metapath2Vec [2].
+GraphSAGE, HinSAGE, and GAT are variants of Graph Convolutional Neural networks [6]. Node2Vec and
 Metapath2Vec are methods based on graph random walks and representation learning using the
-Word2Vec [4] algorithm.
+Word2Vec [5] algorithm. attri2vec[4] is also based on graph random walks and learns node
+representations by performing a mapping on node attributes.
 
 The examples folder structure is shown below.
 
@@ -28,27 +29,34 @@ The examples folder structure is shown below.
     Example of supervised link attribute prediction for a heterogeneous network with attributed nodes of different types,
     using the HinSAGE algorithm.
 
+* [`/attri2vec`](https://github.com/stellargraph/stellargraph/tree/master/demos/link-prediction/attri2vec)
+
+    Example of link prediction for out-of-sample nodes for a homogeneous network with attributed nodes,
+    using the attri2vec algorithm.
 
 ## References
 
-1. Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference on 
+1. Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference on
 Knowledge Discovery and Data Mining (KDD), 2016. ([link](https://snap.stanford.edu/node2vec/))
 
-2. Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and 
+2. Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and
 Ananthram Swami. ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 135–144, 2017
 ([link](https://ericdongyx.github.io/metapath2vec/m2v.html))
 
-3. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216 
+3. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216
 [cs.SI], 2017. ([link](http://snap.stanford.edu/graphsage/))
 
-4. Distributed representations of words and phrases and their compositionality. T. Mikolov, 
+4. Attributed Network Embedding via Subspace Discovery. D. Zhang, J, Yin, X. Zhu and C. Zhang, arXiv:1901.04095,
+[cs.SI], 2019. ([link](https://arxiv.org/abs/1901.04095))
+
+5. Distributed representations of words and phrases and their compositionality. T. Mikolov,
 I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. In Advances in Neural Information Processing
  Systems (NIPS), pp. 3111-3119, 2013. ([link](https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf))
 
-5. Semi-Supervised Classification with Graph Convolutional Networks. T. Kipf, M. Welling. 
+6. Semi-Supervised Classification with Graph Convolutional Networks. T. Kipf, M. Welling.
 ICLR 2017. arXiv:1609.02907 ([link](https://arxiv.org/abs/1609.02907))
 
-6. Graph Attention Networks. P. Velickovic et al. ICLR 2018 ([link](https://arxiv.org/abs/1710.10903))
+7. Graph Attention Networks. P. Velickovic et al. ICLR 2018 ([link](https://arxiv.org/abs/1710.10903))
 
-7. On Calibration of Modern Neural Networks. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger. 
+8. On Calibration of Modern Neural Networks. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger.
 ICML 2017. ([link](https://geoffpleiss.com/nn_calibration))
diff --git a/demos/link-prediction/attri2vec/README.md b/demos/link-prediction/attri2vec/README.md
new file mode 100644
index 000000000..8ce7a6251
--- /dev/null
+++ b/demos/link-prediction/attri2vec/README.md
@@ -0,0 +1,51 @@
+# attri2vec Link Prediction for Out-of-sample Nodes
+
+This is an example of using the attri2vec [1] model, with a link classifier on top,
+to predict links for out-of-sample nodes in a homogeneous citation network.
+
+In this demo, we first train the attri2vec model on the in-sample subgraph and infer
+representations for out-of-sample nodes with the trained attri2vec model. Then we use the
+obtained node representations to perform link prediction for out-of-sample nodes.
+
+The link prediction problem is treated as a supervised binary classification problem for
+`(src, dst)` node pairs that make up links in the graph, with positive examples
+representing links that do exist in the graph, and negative examples representing
+links that don't.
+
+In this example, we learn to predict citation links between papers in a DBLP dataset (see below).
+
+## Requirements
+This example assumes the `stellargraph` library and its requirements have been
+installed by following the installation instructions in the README
+of the library's [root directory](https://github.com/stellargraph/stellargraph).
+
+## DBLP dataset
+
+This example is tested on the DBLP dataset. The attri2vec model assumes that node
+features are available.
+
+The following is the description of the dataset:
+> The DBLP citation network is a subgraph extracted from DBLP-Citation-network V3 (https://aminer.org/citation).
+> To form this subgraph, papers from four subjects are extracted according to their venue information:
+> Database, Data Mining, Artificial Intelligence and Computer Vision, and papers with no citations are removed.
+> The DBLP network contains 18,448 papers and 45,661 citation relations. From paper titles, we construct
+> 2,476-dimensional binary node feature vectors, with each element indicating the presence/absence of the corresponding word.
+> By ignoring the citation direction, we take the DBLP subgraph as an undirected network.
+
+Download and unzip the [DBLP.zip](https://www.kaggle.com/daozhang/dblp-subgraph) file to a location on your computer
+and pass this location as a command line argument to this script.
+
+## Running the notebook
+The narrated version of this example is available in the `stellargraph-attri2vec-DBLP.ipynb` notebook.
+To run the notebook:
+ - Activate the python 3.6 environment in which the
+`stellargraph` library is installed
+ - Start `jupyter-notebook`
+   - note: you may need to first install `jupyter` by running `pip install jupyter` in your python environment
+ - Navigate to the notebook (`/demos/link-prediction/attri2vec/stellargraph-attri2vec-DBLP.ipynb`), and click on
+ it to launch the notebook.
+
+## References
+
+[1] Attributed Network Embedding via Subspace Discovery. D. Zhang, J, Yin, X. Zhu and C. Zhang, arXiv:1901.04095,
+[cs.SI], 2019. ([link](https://arxiv.org/abs/1901.04095))
diff --git a/demos/link-prediction/attri2vec/stellargraph-attri2vec-DBLP.ipynb b/demos/link-prediction/attri2vec/stellargraph-attri2vec-DBLP.ipynb
new file mode 100644
index 000000000..346775154
--- /dev/null
+++ b/demos/link-prediction/attri2vec/stellargraph-attri2vec-DBLP.ipynb
@@ -0,0 +1,925 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Inductive Node Representation Learning through attri2vec"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is the python implementation of the attri2vec algorithm outlined in paper ***[Attributed Network Embedding Via Subspace Discovery](https://arxiv.org/abs/1901.04095)*** D. Zhang, Y. Jie, X. Zhu and C. Zhang, arXiv:1901.04095, [cs.SI], 2019. The implementation uses the stellargraph libraries.\n",
+    "\n",
+    "## attri2vec\n",
+    "\n",
+    "attri2vec learns node representations by performing a linear/non-linear mapping on node content attributes. To make the learned node representations respect structural similarity, [`DeepWalk`](https://dl.acm.org/citation.cfm?id=2623732)/[`node2vec`](https://snap.stanford.edu/node2vec) learning mechanism is used to make nodes sharing similar random walk context nodes represented closely in the subspace, which is achieved by maximizing the occurrence probability of context nodes conditioned on the representation of the target nodes. The probability is modelled by Softmax and negative sampling is used to speed up its calculation. This makes attri2vec equivalent to predict whether a node occurs in the given target node's context in random walks with the representation of the target node, by minimizing the cross-entropy loss. \n",
+    "\n",
+    "In implementation, node embeddings are learnt by solving a simple classification task: given a large set of \"positive\" `(target, context)` node pairs generated from random walks performed on the graph (i.e., node pairs that co-occur within a certain context window in random walks), and an equally large set of \"negative\" node pairs that are randomly selected from the graph according to a certain distribution, learn a binary classifier that predicts whether arbitrary node pairs are likely to co-occur in a random walk performed on the graph. Through learning this simple binary node-pair-classification task, the model automatically learns an inductive mapping from attributes of nodes to node embeddings in a low-dimensional vector space, which preserves structural and feature similarities of the nodes.\n",
+    "\n",
+    "To train the attri2vec model, we first construct a training set of nodes, which is composed of an equal number of positive and negative `(target, context)` pairs from the graph. The positive `(target, context)` pairs are the node pairs co-occurring on random walks over the graph whereas the negative node pairs are the sampled randomly from the global node degree distribution of the graph. In attri2vec, each node is attached with two kinds of embeddings: 1) the inductive 'input embedding', i.e, the objective embedding, obtained by perform a non-linear transformation on node content features, and 2) 'output embedding', i.e., the parameter vector used to predict its occurrence as a context node, obtained by looking up a parameter table. Given a `(target, context)` pair, attri2vec outputs a predictive value to indicate whether it is positive or negative, which is obtained by performing the dot product of the 'input embedding' of the target node and the 'output embedding' of the context node, followed by a sigmoid activation. \n",
+    "\n",
+    "The entire model is trained end-to-end by minimizing the binary cross-entropy loss function with regards to predicted node pair labels and true node pair labels, using stochastic gradient descent (SGD) updates of the model parameters, with minibatches of 'training' node pairs generated on demand and fed into the model.\n",
+    "\n",
+    "In this demo, we first train the attri2vec model on the in-sample subgraph and obtain a mapping function from node attributes to node representations, then apply the mapping function to the content attributes of out-of-sample nodes and obtain the representations of out-of-sample nodes. We evaluate the quality of inferred out-of-sample node representations by using it to predict the links of out-of-sample nodes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import random\n",
+    "\n",
+    "import stellargraph as sg\n",
+    "from stellargraph.data import UnsupervisedSampler\n",
+    "from stellargraph.mapper import Attri2VecLinkGenerator, Attri2VecNodeGenerator\n",
+    "from stellargraph.layer import Attri2Vec, link_classification\n",
+    "\n",
+    "from tensorflow import keras\n",
+    "\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.metrics import roc_auc_score"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading DBLP network data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This demo uses a DBLP citation network, a subgraph extracted from [DBLP-Citation-network V3](https://aminer.org/citation). To form this subgraph, papers from four subjects are extracted according to their venue information: *Database, Data Mining, Artificial Intelligence and Computer Vision*, and papers with no citations are removed. The DBLP network contains 18,448 papers and 45,661 citation relations. From paper titles, we construct 2,476-dimensional binary node feature vectors, with each element indicating the presence/absence of the corresponding word. By ignoring the citation direction, we take the DBLP subgraph as an undirected network.\n",
+    "\n",
+    "As papers in DBLP are attached with publication year, the DBLP network with the dynamic property can be used to study the problem of out-of-sample node representation learning. From the DBLP network, we construct four in-sample subgraphs using papers published before 2006, 2007, 2008 and 2009, and denote the four subgraphs as DBLP2006, DBLP2007, DBLP2008, and DBLP2009. For each subgraph, the remaining papers are taken as out-of-sample nodes. We consider the case where new coming nodes have no links. We predict the links of out-of-sample nodes using the learned out-of-sample node representations and compare its performance with the node content feature baseline.\n",
+    "\n",
+    "The dataset used in this demo can be downloaded from https://www.kaggle.com/daozhang/dblp-subgraph.\n",
+    "The following is the description of the dataset:\n",
+    "\n",
+    "> The content.txt file contains descriptions of the papers in the following format:\n",
+    "\n",
+    " \t\t<paper_id> <word_attributes> <class_label> <publication_year>\n",
+    "        \n",
+    "> The first entry in each line contains the unique integer ID (ranging from 0 to 18,447) of the paper followed by binary values indicating whether each word in the vocabulary is present (indicated by 1) or absent (indicated by 0) in the paper. Finally, the last two entries in the line are the class label and the publication year of the paper.\n",
+    "> The edgeList.txt file contains the citation relations. Each line describes a link in the following format:\n",
+    "\t\t\n",
+    "        <ID of paper1> <ID of paper2>\n",
+    "        \n",
+    "> Each line contains two paper IDs, with paper2 citing paper1 or paper1 citing paper2.\n",
+    "\n",
+    "\n",
+    "Download and unzip the dblp-subgraph.zip file to a location on your computer and set the `data_dir` variable to\n",
+    "point to the location of the dataset (the \"DBLP\" directory containing \"content.txt\" and \"edgeList.txt\")."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_dir = \"~/data/DBLP\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load the graph from the edgelist."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "edgelist = pd.read_csv(os.path.join(data_dir, \"edgeList.txt\"), sep='\\t', header=None, names=[\"source\", \"target\"])\n",
+    "edgelist[\"label\"] = \"cites\"  # set the edge type"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load paper content features, subjects and publishing years."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "feature_names = [\"w_{}\".format(ii) for ii in range(2476)]\n",
+    "node_column_names =  feature_names + [\"subject\", \"year\"]\n",
+    "node_data = pd.read_csv(os.path.join(data_dir, \"content.txt\"), sep='\\t', header=None, names=node_column_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Construct the whole graph from edge list."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G_all_nx = nx.from_pandas_edgelist(edgelist, edge_attr=\"label\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify node types."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nx.set_node_attributes(G_all_nx, \"paper\", \"label\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get node features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_node_features = node_data[feature_names]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create the Stellargraph with node features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G_all = sg.StellarGraph(G_all_nx, node_features=all_node_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "StellarGraph: Undirected multigraph\n",
+      " Nodes: 18448, Edges: 45611\n",
+      "\n",
+      " Node types:\n",
+      "  paper: [18448]\n",
+      "    Edge types: paper-cites->paper\n",
+      "\n",
+      " Edge types:\n",
+      "    paper-cites->paper: [45611]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(G_all.info())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Get DBLP Subgraph \n",
+    "### with papers published before a threshold year"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the edge list connecting in-sample nodes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "year_thresh = 2006 # the threshold year for in-sample and out-of-sample set split, which can be 2007, 2008 and 2009\n",
+    "subgraph_edgelist = []\n",
+    "for ii in range(len(edgelist)):\n",
+    "    source_index = edgelist[\"source\"][ii]\n",
+    "    target_index = edgelist[\"target\"][ii]\n",
+    "    source_year = int(node_data[\"year\"][source_index])\n",
+    "    target_year = int(node_data[\"year\"][target_index])\n",
+    "    if source_year < year_thresh and target_year < year_thresh:\n",
+    "        subgraph_edgelist.append([source_index, target_index])\n",
+    "subgraph_edgelist = pd.DataFrame(np.array(subgraph_edgelist), columns=[\"source\", \"target\"])\n",
+    "subgraph_edgelist[\"label\"] = \"cites\" # set the edge type"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Construct the network from the selected edge list."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G_sub_nx = nx.from_pandas_edgelist(subgraph_edgelist, edge_attr=\"label\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify node types."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nx.set_node_attributes(G_sub_nx, \"paper\", \"label\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the ids of the nodes in the selected subgraph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "subgraph_node_ids = sorted(list(G_sub_nx.nodes))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the node features of the selected subgraph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "subgraph_node_features = node_data[feature_names].reindex(subgraph_node_ids)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create the Stellargraph with node features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G_sub = sg.StellarGraph(G_sub_nx, node_features=subgraph_node_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "StellarGraph: Undirected multigraph\n",
+      " Nodes: 11776, Edges: 28937\n",
+      "\n",
+      " Node types:\n",
+      "  paper: [11776]\n",
+      "    Edge types: paper-cites->paper\n",
+      "\n",
+      " Edge types:\n",
+      "    paper-cites->paper: [28937]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(G_sub.info())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train attri2vec on the DBLP Subgraph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify the other optional parameter values: root nodes, the number of walks to take per node, the length of each walk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nodes = list(G_sub.nodes())\n",
+    "number_of_walks = 2\n",
+    "length = 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create the UnsupervisedSampler instance with the relevant parameters passed to it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "unsupervised_samples = UnsupervisedSampler(G_sub, nodes=nodes, length=length, number_of_walks=number_of_walks)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Set the batch size and the number of epochs. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 50\n",
+    "epochs = 6"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define an attri2vec training generator, which generates a batch of (feature of target node, index of context node, label of node pair) pairs per iteration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running Attri2VecLinkGenerator with an estimated 4710 batches generated on the fly per epoch.\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_gen = Attri2VecLinkGenerator(G_sub, batch_size).flow(unsupervised_samples)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Building the model: a 1-hidden-layer node representation ('input embedding') of the `target` node and the parameter vector ('output embedding') for predicting the existence of `context node` for each `(target context)` pair, with a link classification layer performed on the dot product of the 'input embedding' of the `target` node and the 'output embedding' of the `context` node.\n",
+    "\n",
+    "Attri2Vec part of the model, with a 128-dimenssion hidden layer, no bias term, no dropout and no normalization. (Dropout can be switched on by specifying a positive dropout rate, 0 < dropout < 1 and normalization can be set to 'l2'). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "layer_sizes = [128]\n",
+    "attri2vec = Attri2Vec(\n",
+    "    layer_sizes=layer_sizes, generator=train_gen, bias=False, normalize=None\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: Logging before flag parsing goes to stderr.\n",
+      "W1001 16:10:36.693701 140735704433600 deprecation.py:506] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
+      "W1001 16:10:36.716068 140735704433600 deprecation.py:506] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/keras/initializers.py:119: calling RandomUniform.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Build the model and expose input and output sockets of attri2vec, for node pair inputs:\n",
+    "x_inp, x_out = attri2vec.build()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Use the link_classification function to generate the prediction, with the 'ip' edge embedding generation method and the 'sigmoid' activation, which actually performs the dot product of the 'input embedding' of the target node and the 'output embedding' of the context node followed by a sigmoid activation. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n"
+     ]
+    }
+   ],
+   "source": [
+    "prediction = link_classification(\n",
+    "    output_dim=1, output_act=\"sigmoid\", edge_embedding_method='ip'\n",
+    ")(x_out)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Stack the Attri2Vec encoder and prediction layer into a Keras model, and specify the loss."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = keras.Model(inputs=x_inp, outputs=prediction)\n",
+    "\n",
+    "model.compile(\n",
+    "    optimizer=keras.optimizers.Adam(lr=1e-3),\n",
+    "    loss=keras.losses.binary_crossentropy,\n",
+    "    metrics=[keras.metrics.binary_accuracy],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Train the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "W1001 16:10:37.142501 140735704433600 deprecation.py:323] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/6\n",
+      "4711/4711 [==============================] - 82s 17ms/step - loss: 0.7637 - binary_accuracy: 0.5855\n",
+      "Epoch 2/6\n",
+      "4711/4711 [==============================] - 77s 16ms/step - loss: 0.6452 - binary_accuracy: 0.6117\n",
+      "Epoch 3/6\n",
+      "4711/4711 [==============================] - 76s 16ms/step - loss: 0.5849 - binary_accuracy: 0.6489\n",
+      "Epoch 4/6\n",
+      "4711/4711 [==============================] - 78s 17ms/step - loss: 0.4923 - binary_accuracy: 0.7270\n",
+      "Epoch 5/6\n",
+      "4711/4711 [==============================] - 77s 16ms/step - loss: 0.3702 - binary_accuracy: 0.8201\n",
+      "Epoch 6/6\n",
+      "4711/4711 [==============================] - 80s 17ms/step - loss: 0.2246 - binary_accuracy: 0.9119\n"
+     ]
+    }
+   ],
+   "source": [
+    "history = model.fit_generator(\n",
+    "    train_gen,\n",
+    "    epochs=epochs,\n",
+    "    verbose=1,\n",
+    "    use_multiprocessing=True,\n",
+    "    workers=4,\n",
+    "    shuffle=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predicting links of out-of-sample nodes with the learned attri2vec model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Build the node based model for predicting node representations from node content attributes with the learned parameters. Below a Keras model is constructed, with x_inp[0] as input and x_out[0] as output. Note that this model's weights are the same as those of the corresponding node encoder in the previously trained node pair classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_inp_src = x_inp[0]\n",
+    "x_out_src = x_out[0]\n",
+    "embedding_model = keras.Model(inputs=x_inp_src, outputs=x_out_src)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the node embeddings, for both in-sample and out-of-sample nodes, by applying the learned mapping function to node content features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "369/369 [==============================] - 1s 2ms/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "node_ids = node_data.index\n",
+    "node_gen = Attri2VecNodeGenerator(G_all, batch_size).flow(node_ids)\n",
+    "node_embeddings = embedding_model.predict_generator(node_gen, workers=4, verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the positive and negative edges for in-sample nodes and out-of-sample nodes. The edges of the in-sample nodes only include the edges between in-sample nodes, and the edges of out-of-sample nodes are referred to all the edges linked to out-of-sample nodes, including the edges connecting in-sample and out-of-sample edges."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "year_thresh = 2006\n",
+    "in_sample_edges = []\n",
+    "out_of_sample_edges = []\n",
+    "for ii in range(len(edgelist)):\n",
+    "    source_index = edgelist[\"source\"][ii]\n",
+    "    target_index = edgelist[\"target\"][ii]\n",
+    "    if source_index > target_index: # neglect edge direction for the undirected graph\n",
+    "        continue\n",
+    "    source_year = int(node_data[\"year\"][source_index])\n",
+    "    target_year = int(node_data[\"year\"][target_index])\n",
+    "    if source_year < year_thresh and target_year < year_thresh:\n",
+    "        in_sample_edges.append([source_index, target_index, 1]) # get the positive edge\n",
+    "        negative_target_index = unsupervised_samples.random.choices(node_data.index.tolist(), k=1) # generate negative node\n",
+    "        in_sample_edges.append([source_index, negative_target_index[0], 0]) # get the negative edge\n",
+    "    else:\n",
+    "        out_of_sample_edges.append([source_index, target_index, 1]) # get the positive edge\n",
+    "        negative_target_index = unsupervised_samples.random.choices(node_data.index.tolist(), k=1) # generate negative node\n",
+    "        out_of_sample_edges.append([source_index, negative_target_index[0], 0]) # get the negative edge\n",
+    "in_sample_edges = np.array(in_sample_edges)\n",
+    "out_of_sample_edges = np.array(out_of_sample_edges)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Construct the edge features from the learned node representations with l2 normed difference, where edge features are the element-wise square of the difference between the embeddings of two head nodes. Other strategy like element-wise product can also be used to construct edge features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "in_sample_edge_feat_from_emb = (node_embeddings[in_sample_edges[:,0]]-node_embeddings[in_sample_edges[:,1]])**2\n",
+    "out_of_sample_edge_feat_from_emb = (node_embeddings[out_of_sample_edges[:,0]]-node_embeddings[out_of_sample_edges[:,1]])**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Train the Logistic Regression classifier from in-sample edges with the edge features constructed from attri2vec embeddings. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
+       "                   intercept_scaling=1, l1_ratio=None, max_iter=500,\n",
+       "                   multi_class='auto', n_jobs=None, penalty='l2',\n",
+       "                   random_state=None, solver='lbfgs', tol=0.0001, verbose=0,\n",
+       "                   warm_start=False)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "clf_edge_pred_from_emb = LogisticRegression(verbose=0, solver='lbfgs', multi_class=\"auto\", max_iter=500)\n",
+    "clf_edge_pred_from_emb.fit(in_sample_edge_feat_from_emb, in_sample_edges[:,2])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Predict the edge existence probability with the trained Logistic Regression classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "edge_pred_from_emb = clf_edge_pred_from_emb.predict_proba(out_of_sample_edge_feat_from_emb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the positive class index of `edge_pred_from_emb`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if clf_edge_pred_from_emb.classes_[0] == 1:\n",
+    "    positive_class_index = 0\n",
+    "else:\n",
+    "    positive_class_index = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Evaluate the AUC score for the prediction with attri2vec embeddings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.7927089536523324"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "roc_auc_score(out_of_sample_edges[:,2], edge_pred_from_emb[:,positive_class_index])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As the baseline, we also investigate the performance of node content features in predicting the edges of out-of-sample nodes. Firstly, we construct edge features from node content features with the same strategy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "in_sample_edge_rep_from_feat = (node_data[feature_names].values[in_sample_edges[:,0]]-node_data[feature_names].values[in_sample_edges[:,1]])**2\n",
+    "out_of_sample_edge_rep_from_feat = (node_data[feature_names].values[out_of_sample_edges[:,0]]-node_data[feature_names].values[out_of_sample_edges[:,1]])**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we train the Logistic Regression classifier from in-sample edges with the edge features constructed from node content features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
+       "                   intercept_scaling=1, l1_ratio=None, max_iter=500,\n",
+       "                   multi_class='auto', n_jobs=None, penalty='l2',\n",
+       "                   random_state=None, solver='lbfgs', tol=0.0001, verbose=0,\n",
+       "                   warm_start=False)"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "clf_edge_pred_from_feat = LogisticRegression(verbose=0, solver='lbfgs', multi_class=\"auto\", max_iter=500)\n",
+    "clf_edge_pred_from_feat.fit(in_sample_edge_rep_from_feat, in_sample_edges[:,2])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Predict the edge existence probability with the trained Logistic Regression classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "edge_pred_from_feat = clf_edge_pred_from_feat.predict_proba(out_of_sample_edge_rep_from_feat)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get positive class index of `clf_edge_pred_from_feat`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if clf_edge_pred_from_feat.classes_[0] == 1:\n",
+    "    positive_class_index = 0\n",
+    "else:\n",
+    "    positive_class_index = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Evaluate the AUC score for the prediction with node content features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.6628765045431108"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "roc_auc_score(out_of_sample_edges[:,2], edge_pred_from_feat[:,positive_class_index])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "attri2vec can inductively infer the representations of out-of-sample nodes from their content attributes. As the inferred node representations well capture both structure and node content information, they perform much better than node content features in predicting the links of out-of-sample nodes."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/demos/node-classification/README.md b/demos/node-classification/README.md
index 9dbfd31c6..343d2967a 100644
--- a/demos/node-classification/README.md
+++ b/demos/node-classification/README.md
@@ -6,28 +6,33 @@ examples demonstrate using the `StellarGraph` library to build machine learning
 workflows on both homogeneous and heterogeneous networks.
 
 Each folder contains one or more examples of using the StellarGraph implementations of the
-state-of-the-art algorithms, GraphSAGE [3], HinSAGE, GCN [5], GAT [6], SGC [8], Node2Vec [1], and Metapath2Vec [2]. 
-GraphSAGE, HinSAGE, and GAT are variants of Graph Convolutional Neural networks [5]. Node2Vec and
+state-of-the-art algorithms, attri2vec[4], GraphSAGE [3], HinSAGE, GCN [6], GAT [7], SGC [9], Node2Vec [1], and Metapath2Vec [2].
+GraphSAGE, HinSAGE, and GAT are variants of Graph Convolutional Neural networks [6]. Node2Vec and
 Metapath2Vec are methods based on graph random walks and representation learning using the
-Word2Vec [4] algorithm.
+Word2Vec [5] algorithm. attri2vec[4] is also based on graph random walks, and learns node
+representations by performing a mapping on node attributes.
 
 The examples folder structure is shown below.
 
+* [`/attri2vec`](https://github.com/stellargraph/stellargraph/tree/master/demos/node-classification/graphsage)
+
+    Examples of supervised node classification for two homogeneous networks with attributes, using the attri2vec algorithm [4].
+
 * [`/graphsage`](https://github.com/stellargraph/stellargraph/tree/master/demos/node-classification/graphsage)
 
     Example of supervised node classification for a homogeneous network with attributed nodes, using the GraphSAGE algorithm [3].
-    
+
 * [`/gcn`](https://github.com/stellargraph/stellargraph/tree/master/demos/node-classification/gcn)
 
-    Example of semi-supervised node classification for a homogeneous network, using the GCN algorithm [5].
+    Example of semi-supervised node classification for a homogeneous network, using the GCN algorithm [6].
 
 * [`/sgc`](https://github.com/stellargraph/stellargraph/tree/master/demos/node-classification/sgc)
 
-    Example of semi-supervised node classification for a homogeneous network, using the SGC algorithm [8].
+    Example of semi-supervised node classification for a homogeneous network, using the SGC algorithm [9].
 
 * [`/gat`](https://github.com/stellargraph/stellargraph/tree/master/demos/node-classification/gat)
 
-    Example of supervised node classification for a homogeneous network with attributed nodes, using the GAT algorithm [6].
+    Example of supervised node classification for a homogeneous network with attributed nodes, using the GAT algorithm [7].
 
 * [`/node2vec`](https://github.com/stellargraph/stellargraph/tree/master/demos/node-classification/node2vec)
 
@@ -42,28 +47,30 @@ The examples folder structure is shown below.
 
 ## References
 
-1. Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference on 
+1. Node2Vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference on
 Knowledge Discovery and Data Mining (KDD), 2016. ([link](https://snap.stanford.edu/node2vec/))
 
-2. Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and 
+2. Metapath2Vec: Scalable Representation Learning for Heterogeneous Networks. Yuxiao Dong, Nitesh V. Chawla, and
 Ananthram Swami. ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 135–144, 2017
 ([link](https://ericdongyx.github.io/metapath2vec/m2v.html))
 
-3. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216 
+3. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216
 [cs.SI], 2017. ([link](http://snap.stanford.edu/graphsage/))
 
-4. Distributed representations of words and phrases and their compositionality. T. Mikolov, 
+4. Attributed Network Embedding via Subspace Discovery. D. Zhang, J, Yin, X. Zhu and C. Zhang, arXiv:1901.04095,
+[cs.SI], 2019. ([link](https://arxiv.org/abs/1901.04095))
+
+5. Distributed representations of words and phrases and their compositionality. T. Mikolov,
 I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. In Advances in Neural Information Processing
  Systems (NIPS), pp. 3111-3119, 2013. ([link](https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf))
 
-5. Semi-Supervised Classification with Graph Convolutional Networks. T. Kipf, M. Welling. 
+6. Semi-Supervised Classification with Graph Convolutional Networks. T. Kipf, M. Welling.
 ICLR 2017. arXiv:1609.02907 ([link](https://arxiv.org/abs/1609.02907))
 
-6. Graph Attention Networks. P. Velickovic et al. ICLR 2018 ([link](https://arxiv.org/abs/1710.10903))
+7. Graph Attention Networks. P. Velickovic et al. ICLR 2018 ([link](https://arxiv.org/abs/1710.10903))
 
-7. On Calibration of Modern Neural Networks. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger. 
+8. On Calibration of Modern Neural Networks. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger.
 ICML 2017. ([link](https://geoffpleiss.com/nn_calibration))
 
-8. Simplifying Graph Convolutional Networks. F. Wu, T. Zhang, A. H. de Souza, C. Fifty, T. Yu, and K. Q. Weinberger. 
+9. Simplifying Graph Convolutional Networks. F. Wu, T. Zhang, A. H. de Souza, C. Fifty, T. Yu, and K. Q. Weinberger.
 arXiv:1902.07153. ([link](https://arxiv.org/abs/1902.07153))
-
diff --git a/demos/node-classification/attri2vec/README.md b/demos/node-classification/attri2vec/README.md
new file mode 100644
index 000000000..b28d99268
--- /dev/null
+++ b/demos/node-classification/attri2vec/README.md
@@ -0,0 +1,46 @@
+## Node classification using attri2vec [1]
+
+This folder contains a [Jupyter](http://jupyter.org/) python notebook demonstrating the combined use of
+`stellargraph` (this library) and `Scikit-learn` [2] libraries for node classification in a homogeneous graph
+attached with node attributes.
+
+The example demonstrates node representation learning and node classification using the citeseer
+paper citation network. This demo is included in the Jupyter notebook
+`attri2vec-citeseer-node-classification-example.ipynb`.
+
+The notebook includes all the information for downloading the corresponding dataset, training the attri2vec
+model and using it to classify nodes with unknown (to the training algorithm) labels.
+
+To run the notebook, install Jupyter to the same Python 3.6 environment as StellarGraph, following the instructions on
+the Jupyter project website: http://jupyter.org/install.html
+
+After starting the Jupyter server on your computer, load the notebook and follow the instructions inside.
+
+## Requirements
+
+The example uses Python 3.6 and the StellarGraph library. To install the StellarGraph library
+follow the instructions at: https://github.com/stellargraph/stellargraph
+
+Additional requirements are Pandas, Numpy and Scikit-Learn which are installed as dependencies
+of the StellarGraph library. In addition, Juptyer is required to run the notebook version of
+the example.
+
+## Dataset
+
+The example in this directory uses the citeseer dataset, which can be downloaded from [here](https://linqs-data.soe.ucsc.edu/public/lbc/citesser.tgz).
+
+The following is the description of the dataset:
+> The CiteSeer dataset consists of 3312 scientific publications classified into one of six classes.
+> The citation network consists of 4732 links. Each publication in the dataset is described by a
+> 0/1-valued word vector indicating the absence/presence of the corresponding word from the dictionary.
+> The dictionary consists of 3703 unique words. The README file in the dataset provides more details.
+
+Download and unzip the [citeseer.tgz](https://linqs-data.soe.ucsc.edu/public/lbc/citesser.tgz) file to a location on your
+computer and pass this location as a command line argument to this script.
+
+## References
+
+**1.** Attributed Network Embedding via Subspace Discovery. D. Zhang, J, Yin, X. Zhu and C. Zhang, arXiv:1901.04095,
+[cs.SI], 2019. ([link](https://arxiv.org/abs/1901.04095))
+
+**2.** Scikit-learn: Machine learning in Python ([link](http://scikit-learn.org/stable/))
diff --git a/demos/node-classification/attri2vec/attri2vec-citeseer-node-classification-example.ipynb b/demos/node-classification/attri2vec/attri2vec-citeseer-node-classification-example.ipynb
new file mode 100644
index 000000000..30f7083ff
--- /dev/null
+++ b/demos/node-classification/attri2vec/attri2vec-citeseer-node-classification-example.ipynb
@@ -0,0 +1,829 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Node Representation Learning with attri2vec on Citeseer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is the python implementation of the attri2vec algorithm outlined in paper ***[Attributed Network Embedding Via Subspace Discovery](https://arxiv.org/abs/1901.04095)*** D. Zhang, Y. Jie, X. Zhu and C. Zhang, arXiv:1901.04095, [cs.SI], 2019. The implementation uses the stellargraph libraries.\n",
+    "\n",
+    "\n",
+    "## attri2vec\n",
+    "\n",
+    "attri2vec learns node representations by performing a linear/non-linear mapping on node content attributes. To make the learned node representations respect structural similarity, [`DeepWalk`](https://dl.acm.org/citation.cfm?id=2623732)/[`node2vec`](https://snap.stanford.edu/node2vec) learning mechanism is used to make nodes sharing similar random walk context nodes represented closely in the subspace, which is achieved by maximizing the occurrence probability of context nodes conditioned on the representation of the target nodes. The probability is modelled by Softmax and negative sampling is used to speed up its calculation. This makes attri2vec equivalent to predict whether a node occurs in the given target node's context in random walks with the representation of the target node, by minimizing the cross-entropy loss. \n",
+    "\n",
+    "In implementation, node embeddings are learnt by solving a simple classification task: given a large set of \"positive\" `(target, context)` node pairs generated from random walks performed on the graph (i.e., node pairs that co-occur within a certain context window in random walks), and an equally large set of \"negative\" node pairs that are randomly selected from the graph according to a certain distribution, learn a binary classifier that predicts whether arbitrary node pairs are likely to co-occur in a random walk performed on the graph. Through learning this simple binary node-pair-classification task, the model automatically learns an inductive mapping from attributes of nodes to node embeddings in a low-dimensional vector space, which preserves structural and feature similarities of the nodes. \n",
+    "\n",
+    "To train the attri2vec model, we first construct a training set of nodes, which is composed of an equal number of positive and negative `(target, context)` pairs from the graph. The positive `(target, context)` pairs are the node pairs co-occurring on random walks over the graph whereas the negative node pairs are the sampled randomly from the global node degree distribution of the graph. In attri2vec, each node is attached with two kinds of embeddings: 1) the inductive 'input embedding', i.e, the objective embedding, obtained by perform a linear/non-linear transformation on node content features, and 2) 'output embedding', i.e., the parameter vector used to predict its occurrence as a context node, obtained by looking up a parameter table. Given a `(target, context)` pair, attri2vec outputs a predictive value to indicate whether it is positive or negative, which is obtained by performing the dot product of the 'input embedding' of the target node and the 'output embedding' of the context node, followed by a sigmoid activation. \n",
+    "\n",
+    "The entire model is trained end-to-end by minimizing the binary cross-entropy loss function with regards to predicted node pair labels and true node pair labels, using stochastic gradient descent (SGD) updates of the model parameters, with minibatches of 'training' node pairs generated on demand and fed into the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import random\n",
+    "\n",
+    "import stellargraph as sg\n",
+    "from stellargraph.data import UnsupervisedSampler\n",
+    "from stellargraph.mapper import Attri2VecLinkGenerator, Attri2VecNodeGenerator\n",
+    "from stellargraph.layer import Attri2Vec, link_classification\n",
+    "\n",
+    "from tensorflow import keras\n",
+    "\n",
+    "from pandas.core.indexes.base import Index\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.manifold import TSNE\n",
+    "from sklearn.decomposition import PCA\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LogisticRegressionCV\n",
+    "from sklearn.metrics import accuracy_score"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The dataset is the citation network Citeseer.\n",
+    "\n",
+    "It can be downloaded by clicking [here](https://linqs-data.soe.ucsc.edu/public/lbc/citesser.tgz)\n",
+    "\n",
+    "The following is the description of the dataset from the publisher,\n",
+    "> The CiteSeer dataset consists of 3312 scientific publications classified into one of six classes. The citation network consists of 4732 links. Each publication in the dataset is described by a 0/1-valued word vector indicating the absence/presence of the corresponding word from the dictionary. The dictionary consists of 3703 unique words. The README file in the dataset provides more details.\n",
+    "\n",
+    "Download and unzip the citeseer.tgz file to a location on your computer. \n",
+    "\n",
+    "We assume that the dataset is stored in the directory\n",
+    "\n",
+    "`~/data/citeseer/`\n",
+    "\n",
+    "where the files `citeseer.cites` and `citeseer.content` can be located.\n",
+    "\n",
+    "We are going to load the data into a networkx object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_dir = \"~/data/citeseer\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load edges in order 'cited-paper' <- 'citing-paper'."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "citeseer_location = os.path.expanduser(os.path.join(data_dir, \"citeseer.cites\"))\n",
+    "g_nx = nx.read_edgelist(path=citeseer_location, create_using=nx.DiGraph()).reverse()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Convert the graph to undirected graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g_nx = g_nx.to_undirected()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load the node attribute data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3057: DtypeWarning: Columns (0) have mixed types. Specify dtype option on import or set low_memory=False.\n",
+      "  interactivity=interactivity, compiler=compiler, result=result)\n"
+     ]
+    }
+   ],
+   "source": [
+    "citeseer_data_location = os.path.expanduser(os.path.join(data_dir, \"citeseer.content\"))\n",
+    "attr_names = [\"w_{}\".format(ii) for ii in range(3703)]\n",
+    "node_column_names =  attr_names + [\"subject\"]\n",
+    "node_attr = pd.read_csv(citeseer_data_location, sep='\\t', header=None, names=node_column_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Change the type of the indexes of node_attr to str."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_attr.index = Index(list(map(str, list(node_attr.index))))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The original graph contains some nodes with no attributes. We remove them here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g_nx = g_nx.subgraph(list(node_attr.index))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Select the largest connected component. For clarity we ignore isolated nodes and subgraphs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Largest subgraph statistics: 2110 nodes, 3720 edges\n"
+     ]
+    }
+   ],
+   "source": [
+    "g_nx_ccs = (g_nx.subgraph(c).copy() for c in nx.connected_components(g_nx))\n",
+    "g_nx = max(g_nx_ccs, key=len)\n",
+    "print(\"Largest subgraph statistics: {} nodes, {} edges\".format(\n",
+    "    g_nx.number_of_nodes(), g_nx.number_of_edges()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify node types."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nx.set_node_attributes(g_nx, \"paper\", \"label\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the ids of the nodes in the selected largest connected component. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_ids = sorted(list(g_nx.nodes))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get node features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_features = node_attr[attr_names].reindex(node_ids)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create the Stellargraph with node features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = sg.StellarGraph(g_nx, node_features=node_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "StellarGraph: Undirected multigraph\n",
+      " Nodes: 2110, Edges: 3720\n",
+      "\n",
+      " Node types:\n",
+      "  paper: [2110]\n",
+      "    Edge types: paper-default->paper\n",
+      "\n",
+      " Edge types:\n",
+      "    paper-default->paper: [3720]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(G.info())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train attri2vec on Citeseer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify the other optional parameter values: root nodes, the number of walks to take per node, the length of each walk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nodes = list(G.nodes())\n",
+    "number_of_walks = 4\n",
+    "length = 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create the UnsupervisedSampler instance with the relevant parameters passed to it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "unsupervised_samples = UnsupervisedSampler(G, nodes=nodes, length=length, number_of_walks=number_of_walks)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Set the batch size and the number of epochs. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 50\n",
+    "epochs = 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define an attri2vec training generator, which generates a batch of (feature of target node, index of context node, label of node pair) pairs per iteration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running Attri2VecLinkGenerator with an estimated 1688 batches generated on the fly per epoch.\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_gen = Attri2VecLinkGenerator(G, batch_size).flow(unsupervised_samples)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Building the model: a 1-hidden-layer node representation ('input embedding') of the `target` node and the parameter vector ('output embedding') for predicting the existence of `context node` for each `(target context)` pair, with a link classification layer performed on the dot product of the 'input embedding' of the `target` node and the 'output embedding' of the `context` node.\n",
+    "\n",
+    "Attri2Vec part of the model, with a 128-dimenssion hidden layer, no bias term and no normalization. (Normalization can be set to 'l2'). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "layer_sizes = [128]\n",
+    "attri2vec = Attri2Vec(\n",
+    "    layer_sizes=layer_sizes, generator=train_gen, bias=False, normalize=None\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: Logging before flag parsing goes to stderr.\n",
+      "W1001 15:56:58.801946 140735704433600 deprecation.py:506] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
+      "W1001 15:56:58.822957 140735704433600 deprecation.py:506] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/keras/initializers.py:119: calling RandomUniform.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Build the model and expose input and output sockets of attri2vec, for node pair inputs:\n",
+    "x_inp, x_out = attri2vec.build()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Use the link_classification function to generate the prediction, with the 'ip' edge embedding generation method and the 'sigmoid' activation, which actually performs the dot product of the 'input embedding' of the target node and the 'output embedding' of the context node followed by a sigmoid activation. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n"
+     ]
+    }
+   ],
+   "source": [
+    "prediction = link_classification(\n",
+    "    output_dim=1, output_act=\"sigmoid\", edge_embedding_method='ip'\n",
+    ")(x_out)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Stack the Attri2Vec encoder and prediction layer into a Keras model, and specify the loss."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = keras.Model(inputs=x_inp, outputs=prediction)\n",
+    "\n",
+    "model.compile(\n",
+    "    optimizer=keras.optimizers.Adam(lr=1e-3),\n",
+    "    loss=keras.losses.binary_crossentropy,\n",
+    "    metrics=[keras.metrics.binary_accuracy],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Train the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "W1001 15:56:59.080938 140735704433600 deprecation.py:323] From /anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1688/1688 [==============================] - 13s 8ms/step - loss: 0.6828 - binary_accuracy: 0.5543\n",
+      "Epoch 2/4\n",
+      "1688/1688 [==============================] - 11s 6ms/step - loss: 0.5131 - binary_accuracy: 0.7586\n",
+      "Epoch 3/4\n",
+      "1688/1688 [==============================] - 11s 6ms/step - loss: 0.3334 - binary_accuracy: 0.8769\n",
+      "Epoch 4/4\n",
+      "1688/1688 [==============================] - 11s 7ms/step - loss: 0.2462 - binary_accuracy: 0.9157\n"
+     ]
+    }
+   ],
+   "source": [
+    "history = model.fit_generator(\n",
+    "    train_gen,\n",
+    "    epochs=epochs,\n",
+    "    verbose=1,\n",
+    "    use_multiprocessing=False,\n",
+    "    workers=1,\n",
+    "    shuffle=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##  Visualise Node Embeddings"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Build the node based model for predicting node representations from node content attributes with the learned parameters. Below a Keras model is constructed, with x_inp[0] as input and x_out[0] as output. Note that this model's weights are the same as those of the corresponding node encoder in the previously trained node pair classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_inp_src = x_inp[0]\n",
+    "x_out_src = x_out[0]\n",
+    "embedding_model = keras.Model(inputs=x_inp_src, outputs=x_out_src)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get the node embeddings by applying the learned mapping function to node content features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "43/43 [==============================] - 0s 2ms/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "node_gen = Attri2VecNodeGenerator(G, batch_size).flow(node_ids)\n",
+    "node_embeddings = embedding_model.predict_generator(node_gen, workers=1, verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get node subjects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node_targets = [ node_attr[\"subject\"][node_id] for node_id in node_ids ]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Transform the embeddings to 2d space for visualisation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transform = TSNE # PCA\n",
+    "\n",
+    "trans = transform(n_components=2)\n",
+    "node_embeddings_2d = trans.fit_transform(node_embeddings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# draw the embedding points, coloring them by the target label (paper subject)\n",
+    "alpha = 0.7\n",
+    "label_map = { l: i for i, l in enumerate(np.unique(node_targets)) }\n",
+    "node_colours = [ label_map[target] for target in node_targets ]\n",
+    "\n",
+    "plt.figure(figsize=(7,7))\n",
+    "plt.axes().set(aspect=\"equal\")\n",
+    "plt.scatter(node_embeddings_2d[:,0], \n",
+    "            node_embeddings_2d[:,1], \n",
+    "            c=node_colours, cmap=\"jet\", alpha=alpha)\n",
+    "plt.title('{} visualization of node embeddings'.format(transform.__name__))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Node Classificaion Task"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The embeddings learned by `attri2vec` can be used as feature vectors in downstream tasks, such as node classification and link prediction.\n",
+    "\n",
+    "In this example, we will use the `attri2vec` node embeddings to train a classifier to predict the subject of a paper in DBLP."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# X will hold the 128-dimensional input features\n",
+    "X = node_embeddings  \n",
+    "# y holds the corresponding target values\n",
+    "y = np.array(node_targets)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data Splitting\n",
+    "\n",
+    "We split the data into train and test sets. \n",
+    "\n",
+    "We use 10% of the data for training and the remaining 90% for testing as a hold out test set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Array shapes:\n",
+      " X_train = (211, 128)\n",
+      " y_train = (211,)\n",
+      " X_test = (1899, 128)\n",
+      " y_test = (1899,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.1, test_size=None)\n",
+    "print(\"Array shapes:\\n X_train = {}\\n y_train = {}\\n X_test = {}\\n y_test = {}\".format(X_train.shape, y_train.shape, X_test.shape, y_test.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Classifier Training\n",
+    "\n",
+    "We train a Logistic Regression classifier on the training data. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.6/site-packages/sklearn/model_selection/_split.py:657: Warning: The least populated class in y has only 9 members, which is too few. The minimum number of members in any class cannot be less than n_splits=10.\n",
+      "  % (min_groups, self.n_splits)), Warning)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "LogisticRegressionCV(Cs=10, class_weight=None, cv=10, dual=False,\n",
+       "                     fit_intercept=True, intercept_scaling=1.0, l1_ratios=None,\n",
+       "                     max_iter=300, multi_class='ovr', n_jobs=None, penalty='l2',\n",
+       "                     random_state=None, refit=True, scoring='accuracy',\n",
+       "                     solver='lbfgs', tol=0.0001, verbose=False)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "clf = LogisticRegressionCV(\n",
+    "    Cs=10, \n",
+    "    cv=10, \n",
+    "    scoring=\"accuracy\",\n",
+    "    verbose=False,\n",
+    "    multi_class='ovr',\n",
+    "    max_iter=300\n",
+    ")\n",
+    "clf.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Predict the hold-out test set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = clf.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Calculate the accuracy of the classifier on the test set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.7546076882569773"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "accuracy_score(y_test, y_pred)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/api.txt b/docs/api.txt
old mode 100644
new mode 100755
index 5b2f71de8..2844bf427
--- a/docs/api.txt
+++ b/docs/api.txt
@@ -19,7 +19,7 @@ Generators
 -----------
 
 .. automodule:: stellargraph.mapper
-  :members: FullBatchNodeGenerator, GraphSAGENodeGenerator, GraphSAGELinkGenerator, HinSAGENodeGenerator, HinSAGELinkGenerator
+  :members: FullBatchNodeGenerator, GraphSAGENodeGenerator, GraphSAGELinkGenerator, HinSAGENodeGenerator, HinSAGELinkGenerator, Attri2VecNodeGenerator, Attri2VecLinkGenerator
 
 
 GraphSAGE model
@@ -36,6 +36,13 @@ HinSAGE model
   :members: HinSAGE, MeanHinAggregator
 
 
+Attri2Vec model
+----------------
+
+.. automodule:: stellargraph.layer.attri2vec
+  :members: Attri2Vec
+
+
 GCN model
 -------------
 
diff --git a/stellargraph/core/graph.py b/stellargraph/core/graph.py
index 4c9038250..cd45e59f1 100644
--- a/stellargraph/core/graph.py
+++ b/stellargraph/core/graph.py
@@ -433,6 +433,44 @@ def check_graph_for_ml(self, features=True):
 
         # TODO: check the feature node_ids against the graph node ids?
 
+    def get_index_for_nodes(self, nodes, node_type=None):
+        """
+        Get the indices for the specified node or nodes.
+        If the node type is not specified the node types will be found
+        for all nodes. It is therefore important to supply the ``node_type``
+        for this method to be fast.
+
+        Args:
+            n: (list or hashable) Node ID or list of node IDs
+            node_type: (hashable) the type of the nodes.
+
+        Returns:
+            Numpy array containing the indices for the requested nodes.
+        """
+        if not is_real_iterable(nodes):
+            nodes = [nodes]
+
+        # Get the node type if not specified.
+        if node_type is None:
+            node_types = {
+                self._get_node_type(self.node[n]) for n in nodes if n is not None
+            }
+
+            if len(node_types) > 1:
+                raise ValueError("All nodes must be of the same type.")
+
+            if len(node_types) == 0:
+                raise ValueError(
+                    "At least one node must be given if node_type not specified"
+                )
+
+            node_type = node_types.pop()
+
+        # Get index for nodes of this type
+        nt_id_to_index = self._node_index_maps[node_type]
+        node_indices = [nt_id_to_index.get(n) for n in nodes]
+        return node_indices
+
     def get_feature_for_nodes(self, nodes, node_type=None):
         """
         Get the numeric feature vectors for the specified node or nodes.
diff --git a/stellargraph/layer/__init__.py b/stellargraph/layer/__init__.py
old mode 100644
new mode 100755
index 87926b106..228c7ce0b
--- a/stellargraph/layer/__init__.py
+++ b/stellargraph/layer/__init__.py
@@ -27,5 +27,6 @@
 from .graph_attention import *
 from .link_inference import *
 from .gcn import *
+from .attri2vec import *
 from .misc import SqueezedSparseConversion
 from .preprocessing_layer import GraphPreProcessingLayer
diff --git a/stellargraph/layer/attri2vec.py b/stellargraph/layer/attri2vec.py
new file mode 100644
index 000000000..c4d7b2b72
--- /dev/null
+++ b/stellargraph/layer/attri2vec.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2018 Data61, CSIRO
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+attri2vec
+
+"""
+__all__ = ["Attri2Vec"]
+
+from tensorflow.keras import Input
+from tensorflow.keras import backend as K
+from tensorflow.keras.layers import Dense, Lambda, Reshape, Embedding
+import warnings
+
+
+class Attri2Vec:
+    """
+    Implementation of the attri2vec algorithm of Zhang et al. with Keras layers.
+    see: https://arxiv.org/abs/1901.04095.
+
+    The model minimally requires specification of the layer sizes as a list of ints
+    corresponding to the feature dimensions for each hidden layer and a generator object.
+
+    Args:
+        layer_sizes (list): Hidden feature dimensions for each layer.
+        generator (Sequence): A NodeSequence or LinkSequence. 
+        input_dim (int): The dimensions of the node features used as input to the model.
+        node_num (int): The number of nodes in the given graph.
+        bias (bool): If True a bias vector is learnt for each layer in the attri2vec model, default to False.
+        activation (str): The activation function of each layer in the attri2vec model, which takes values from "linear", "relu" and "sigmoid"(default).
+        normalize ("l2" or None): The normalization used after each layer, default to None.
+
+    """
+
+    def __init__(
+        self,
+        layer_sizes,
+        generator=None,
+        input_dim=None,
+        node_num=None,
+        bias=False,
+        activation="sigmoid",
+        normalize=None,
+    ):
+
+        if activation == "linear" or activation == "relu" or activation == "sigmoid":
+            self.activation = activation
+        else:
+            raise ValueError(
+                "Activation should be either 'linear', 'relu' or 'sigmoid'; received '{}'".format(
+                    activation
+                )
+            )
+
+        if normalize == "l2":
+            self._normalization = Lambda(lambda x: K.l2_normalize(x, axis=-1))
+
+        elif normalize is None:
+            self._normalization = Lambda(lambda x: x)
+
+        else:
+            raise ValueError(
+                "Normalization should be either 'l2' or None; received '{}'".format(
+                    normalize
+                )
+            )
+
+        # Get the input_dim and node_num from the generator if it is given
+        self.generator = generator
+        if generator is not None:
+            feature_sizes = generator.generator.graph.node_feature_sizes()
+            if len(feature_sizes) > 1:
+                raise RuntimeError(
+                    "Attri2Vec called on graph with more than one node type."
+                )
+
+            self.input_feature_size = feature_sizes.popitem()[1]
+            self.input_node_num = generator.generator.graph.number_of_nodes()
+
+        elif input_dim is not None and node_num is not None:
+            self.input_feature_size = input_dim
+            self.input_node_num = node_num
+
+        else:
+            raise RuntimeError(
+                "If generator is not provided, input_dim and node_num must be specified."
+            )
+
+        # Model parameters
+        self.n_layers = len(layer_sizes)
+        self.bias = bias
+
+        # Feature dimensions for each layer
+        self.dims = [self.input_feature_size] + layer_sizes
+
+    def __call__(self, xin):
+        """
+        Construct node representations from node attributes through deep neural network
+
+        Args:
+            xin (Keras Tensor): Batch input features
+
+        Returns:
+            Output tensor
+        """
+        # Form Attri2Vec layers iteratively
+        h_layer = xin
+        for layer in range(0, self.n_layers):
+            h_layer = Dense(
+                self.dims[layer + 1], activation=self.activation, use_bias=self.bias
+            )(h_layer)
+            h_layer = self._normalization(h_layer)
+
+        return h_layer
+
+    def node_model(self):
+        """
+        Builds a Attri2Vec model for node representation prediction.
+
+        Returns:
+            tuple: (x_inp, x_out) where ``x_inp`` is a Keras input tensor
+            for the Attri2Vec model and ``x_out`` is the Keras tensor
+            for the Attri2Vec model output.
+
+        """
+        # Create tensor inputs
+        x_inp = Input(shape=(self.input_feature_size,))
+
+        # Output from Attri2Vec model
+        x_out = self(x_inp)
+
+        return x_inp, x_out
+
+    def link_model(self):
+        """
+        Builds a Attri2Vec model for context node prediction.
+
+        Returns:
+            tuple: (x_inp, x_out) where ``x_inp`` is a list of Keras input tensors for (src, dst) nodes in the node pairs
+            and ``x_out`` is a list of output tensors for (src, dst) nodes in the node pairs
+
+        """
+        # Expose input and output sockets of the model, for source node:
+        x_inp_src, x_out_src = self.node_model()
+
+        # Expose input and out sockets of the model, for target node:
+        x_inp_dst = Input(shape=(1,))
+        output_embedding = Embedding(
+            self.input_node_num,
+            self.dims[self.n_layers],
+            input_length=1,
+            name="output_embedding",
+        )
+        x_out_dst = output_embedding(x_inp_dst)
+        x_out_dst = Reshape((self.dims[self.n_layers],))(x_out_dst)
+
+        x_inp = [x_inp_src, x_inp_dst]
+        x_out = [x_out_src, x_out_dst]
+        return x_inp, x_out
+
+    def build(self):
+        """
+        Builds a Attri2Vec model for context node prediction.
+
+        Returns:
+            tuple: (x_inp, x_out), where ``x_inp`` contains Keras input tensor(s)
+            for the Attri2Vec model to perform context node prediction and ``x_out`` contains
+            model output tensor(s) of shape (batch_size, layer_sizes[-1]).
+
+        """
+        return self.link_model()
+
+    def default_model(self, flatten_output=True):
+        warnings.warn(
+            "The .default_model() method will be deprecated in future versions. "
+            "Please use .build() method instead.",
+            PendingDeprecationWarning,
+        )
+        return self.build()
diff --git a/stellargraph/mapper/link_mappers.py b/stellargraph/mapper/link_mappers.py
old mode 100644
new mode 100755
index 111a11986..cdaaa9228
--- a/stellargraph/mapper/link_mappers.py
+++ b/stellargraph/mapper/link_mappers.py
@@ -16,7 +16,7 @@
 
 """
 Generators that create batches of data from a machine-learnign ready graph
-for link prediction/link attribute inference problems using GraphSAGE and HinSAGE.
+for link prediction/link attribute inference problems using GraphSAGE, HinSAGE and Attri2Vec.
 
 """
 __all__ = [
@@ -24,6 +24,7 @@
     "OnDemandLinkSequence",
     "GraphSAGELinkGenerator",
     "HinSAGELinkGenerator",
+    "Attri2VecLinkGenerator",
 ]
 
 import random
@@ -56,11 +57,12 @@ class LinkSequence(Sequence):
     :meth:`keras.Model.evaluate_generator`, and :meth:`keras.Model.predict_generator`
     This class generates data samples for link inference models
     and should be created using the :meth:`flow` method of
-    :class:`GraphSAGELinkGenerator` or :class:`HinSAGELinkGenerator` .
+    :class:`GraphSAGELinkGenerator` or :class:`HinSAGELinkGenerator` or :class:`Attri2VecLinkGenerator`.
     Args:
-        generator: An instance of :class:`GraphSAGELinkGenerator` or :class:`HinSAGELinkGenerator`.
+        generator: An instance of :class:`GraphSAGELinkGenerator` or :class:`HinSAGELinkGenerator` or 
+        :class:`Attri2VecLinkGenerator`.
         ids (list or iterable): Link IDs to batch, each link id being a tuple of (src, dst) node ids.
-            (The graph nodes must have a "feature" attribute that is used as input to the GraphSAGE model.)
+            (The graph nodes must have a "feature" attribute that is used as input to the GraphSAGE/Attri2Vec model.)
             These are the links that are to be used to train or inference, and the embeddings
             calculated for these links via a binary operator applied to their source and destination nodes,
             are passed to the downstream task of link prediction or link attribute inference.
@@ -91,7 +93,19 @@ def __init__(self, generator, ids, targets=None, shuffle=True):
         if targets is not None and len(ids) != len(targets):
             raise ValueError("Length of link ids must match length of link targets")
 
-        self.generator = generator
+        if (
+            isinstance(generator, GraphSAGELinkGenerator)
+            or isinstance(generator, HinSAGELinkGenerator)
+            or isinstance(generator, Attri2VecLinkGenerator)
+        ):
+            self.generator = generator
+        else:
+            raise TypeError(
+                "({}) GraphSAGELinkGenerator, HinSAGELinkGenerator or Attri2VecLinkGenerator is required.".format(
+                    type(self).__name__
+                )
+            )
+
         self.ids = list(ids)
         self.data_size = len(self.ids)
         self.shuffle = shuffle
@@ -99,17 +113,20 @@ def __init__(self, generator, ids, targets=None, shuffle=True):
         # Shuffle the IDs to begin
         self.on_epoch_end()
 
-        # Get head node types from all src, dst nodes extracted from all links,
-        # and make sure there's only one pair of node types:
-        self.head_node_types = self._infer_head_node_types(generator.schema)
+        if isinstance(self.generator, GraphSAGELinkGenerator) or isinstance(
+            self.generator, HinSAGELinkGenerator
+        ):
+            # Get head node types from all src, dst nodes extracted from all links,
+            # and make sure there's only one pair of node types:
+            self.head_node_types = self._infer_head_node_types(generator.schema)
 
-        self._sampling_schema = generator.schema.sampling_layout(
-            self.head_node_types, generator.num_samples
-        )
+            self._sampling_schema = generator.schema.sampling_layout(
+                self.head_node_types, generator.num_samples
+            )
 
-        self.type_adjacency_list = generator.schema.type_adjacency_list(
-            self.head_node_types, len(generator.num_samples)
-        )
+            self.type_adjacency_list = generator.schema.type_adjacency_list(
+                self.head_node_types, len(generator.num_samples)
+            )
 
     def _infer_head_node_types(self, schema):
         """Get head node types from all src, dst nodes extracted from all links in self.ids"""
@@ -155,8 +172,16 @@ def __getitem__(self, batch_num):
         # Get targets for nodes
         batch_targets = None if self.targets is None else self.targets[batch_indices]
 
-        # Get sampled nodes
-        batch_feats = self.generator.sample_features(head_ids, self._sampling_schema)
+        if isinstance(self.generator, GraphSAGELinkGenerator) or isinstance(
+            self.generator, HinSAGELinkGenerator
+        ):
+            # Get sampled nodes for GraphSAGELinkGenerator and HinSAGELinkGenerator
+            batch_feats = self.generator.sample_features(
+                head_ids, self._sampling_schema
+            )
+        else:
+            # Get sampled nodes for Attri2VecLinkGenerator
+            batch_feats = self.generator.sample_features(head_ids)
 
         return batch_feats, batch_targets
 
@@ -176,10 +201,10 @@ class OnDemandLinkSequence(Sequence):
 
     This class generates data samples for link inference models
     and should be created using the :meth:`flow` method of
-    :class:`GraphSAGELinkGenerator` ` .
+    :class:`GraphSAGELinkGenerator` or :class:`Attri2VecLinkGenerator`.
 
     Args:
-        generator: An instance of :class:`GraphSAGELinkGenerator`.
+        generator: An instance of :class:`GraphSAGELinkGenerator` or 'Attri2VecLinkGenerator'.
         sampler:  An instance of :class:`UnsupervisedSampler` that encapsulates the neighbourhood sampling of a graph.
         The generator method of this class returns `batch_size` of positive and negative samples on demand.
     """
@@ -188,14 +213,25 @@ def __init__(self, generator, walker):
 
         self.lock = threading.Lock()
 
-        self.generator = generator  # graphlinkgenerator instance
+        if isinstance(generator, GraphSAGELinkGenerator) or isinstance(
+            generator, Attri2VecLinkGenerator
+        ):
+            self.generator = generator
+        else:
+            raise TypeError(
+                "({}) GraphSAGELinkGenerator or Attri2VecLinkGenerator is required.".format(
+                    type(self).__name__
+                )
+            )
 
-        self.head_node_types = self.generator.schema.node_types * 2
+        if isinstance(self.generator, GraphSAGELinkGenerator):
 
-        # YT: we need to have self._sampling_schema for GraphSAGE.build() method to work
-        self._sampling_schema = generator.schema.sampling_layout(
-            self.head_node_types, generator.num_samples
-        )
+            self.head_node_types = self.generator.schema.node_types * 2
+
+            # YT: we need to have self._sampling_schema for GraphSAGE.build() method to work
+            self._sampling_schema = generator.schema.sampling_layout(
+                self.head_node_types, generator.num_samples
+            )
 
         if isinstance(walker, UnsupervisedSampler):
 
@@ -208,11 +244,18 @@ def __init__(self, generator, walker):
                 * self.walker.number_of_walks
             )  # an estimate of the  upper bound on how many samples are generated in each epoch
 
-            print(
-                "Running GraphSAGELinkGenerator with an estimated {} batches generated on the fly per epoch.".format(
-                    round(self.data_size / self.generator.batch_size)
+            if isinstance(self.generator, GraphSAGELinkGenerator):
+                print(
+                    "Running GraphSAGELinkGenerator with an estimated {} batches generated on the fly per epoch.".format(
+                        round(self.data_size / self.generator.batch_size)
+                    )
+                )
+            else:
+                print(
+                    "Running Attri2VecLinkGenerator with an estimated {} batches generated on the fly per epoch.".format(
+                        round(self.data_size / self.generator.batch_size)
+                    )
                 )
-            )
 
             self._gen = self.walker.generator(
                 self.generator.batch_size
@@ -247,24 +290,31 @@ def __getitem__(self, batch_num):
         head_ids, batch_targets = next(self._gen)
         self.lock.release()
 
-        if self.head_node_types is None:
+        if isinstance(self.generator, GraphSAGELinkGenerator):
 
-            # Get head node types from all src, dst nodes extracted from all links,
-            # and make sure there's only one pair of node types:
-            self.head_node_types = self._infer_head_node_types(
-                self.generator.schema, head_ids
-            )
+            if self.head_node_types is None:
 
-            self._sampling_schema = self.generator.schema.sampling_layout(
-                self.head_node_types, self.generator.num_samples
-            )
+                # Get head node types from all src, dst nodes extracted from all links,
+                # and make sure there's only one pair of node types:
+                self.head_node_types = self._infer_head_node_types(
+                    self.generator.schema, head_ids
+                )
 
-            self.type_adjacency_list = self.generator.schema.type_adjacency_list(
-                self.head_node_types, len(self.generator.num_samples)
-            )
+                self._sampling_schema = self.generator.schema.sampling_layout(
+                    self.head_node_types, self.generator.num_samples
+                )
 
-        # Get sampled nodes
-        batch_feats = self.generator.sample_features(head_ids, self._sampling_schema)
+                self.type_adjacency_list = self.generator.schema.type_adjacency_list(
+                    self.head_node_types, len(self.generator.num_samples)
+                )
+
+            # Get sampled nodes for GraphSAGELinkGenerator
+            batch_feats = self.generator.sample_features(
+                head_ids, self._sampling_schema
+            )
+        else:
+            # Get sampled nodes for Attri2VecLinkGenerator
+            batch_feats = self.generator.sample_features(head_ids)
 
         return batch_feats, batch_targets
 
@@ -403,7 +453,7 @@ def flow(self, link_ids, targets=None, shuffle=False):
         supplied link_ids to be used by the downstream task. They should
         be given in the same order as the list of link IDs.
         If they are not specified (for example, for use in prediction),
-        the targets will not be available to the downsteam task.
+        the targets will not be available to the downstream task.
 
         Note that the shuffle argument should be True for training and
         False for prediction.
@@ -581,7 +631,7 @@ def flow(self, link_ids, targets=None, shuffle=False):
         supplied link_ids to be used by the downstream task. They should
         be given in the same order as the list of link IDs.
         If they are not specified (for example, for use in prediction),
-        the targets will not be available to the downsteam task.
+        the targets will not be available to the downstream task.
 
         Note that the shuffle argument should be True for training and
         False for prediction.
@@ -605,3 +655,97 @@ def flow(self, link_ids, targets=None, shuffle=False):
             )
 
         return LinkSequence(self, link_ids, targets, shuffle)
+
+
+class Attri2VecLinkGenerator:
+    """
+    A data generator for context node prediction with the attri2vec model.
+
+    At minimum, supply the StellarGraph and the batch size.
+
+    The supplied graph should be a StellarGraph object that is ready for
+    machine learning. Currently the model requires node features for all
+    nodes in the graph.
+
+    Use the :meth:`.flow` method supplying the nodes and targets,
+    or an UnsupervisedSampler instance that generates node samples on demand,
+    to get an object that can be used as a Keras data generator.
+
+    Example::
+
+        G_generator = Attri2VecLinkGenerator(G, 50)
+        train_data_gen = G_generator.flow(edge_ids, edge_labels)
+
+    Args:
+        G (StellarGraph): A machine-learning ready graph.
+        batch_size (int): Size of batch of links to return.
+        name, optional: Name of generator.
+    """
+
+    def __init__(self, G, batch_size, name=None):
+        if not isinstance(G, StellarGraphBase):
+            raise TypeError("Graph must be a StellarGraph object.")
+
+        # Check if the graph has features
+        G.check_graph_for_ml(features=True)
+
+        self.graph = G
+        self.batch_size = batch_size
+        self.name = name
+
+    def sample_features(self, head_links):
+        """
+        Sample content features of the target nodes and the ids of the context nodes
+        and return these as a list of feature arrays for the attri2vec algorithm.
+
+        Args:
+            head_links: An iterable of edges to perform sampling for.
+
+        Returns:
+            A list of feature arrays, with each element being the feature of a
+            target node and the id of the corresponding context node.
+        """
+
+        target_ids = [head_link[0] for head_link in head_links]
+        context_ids = [head_link[1] for head_link in head_links]
+        target_feats = self.graph.get_feature_for_nodes(target_ids)
+        context_feats = self.graph.get_index_for_nodes(context_ids)
+        batch_feats = [target_feats, np.array(context_feats)]
+
+        return batch_feats
+
+    def flow(self, link_ids, targets=None):
+        """
+        Creates a generator/sequence object for training
+        with the supplied edge IDs and numeric targets.
+
+        The edge IDs are the edges to train. They are
+        expected to by tuples of (source_id, destination_id).
+
+        The targets are an array of numeric targets corresponding to the
+        supplied link_ids to be used by the attri2vec context node prediction task. 
+        They should be given in the same order as the list of link IDs.
+
+        Args:
+            link_ids (list or UnsupervisedSampler): an iterable of (src_id, dst_id) tuples
+                specifying the edges or an UnsupervisedSampler object that has a generator
+                method to generate samples on the fly.
+            targets (optional, array): a 2D array of numeric targets with shape
+                `(len(link_ids), target_size)`.
+
+        Returns:
+            An OnDemandLinkSequence object to use with the attri2vec model.
+        """
+        # Pass sampler to on-demand link sequence generation
+        if isinstance(link_ids, UnsupervisedSampler):
+            return OnDemandLinkSequence(self, link_ids)
+
+        # Otherwise pass iterable to standard LinkSequence
+        elif isinstance(link_ids, collections.Iterable):
+            return LinkSequence(self, link_ids, targets, shuffle=True)
+
+        else:
+            raise TypeError(
+                "Argument to .flow not recognised. "
+                "Please pass a list of samples or a UnsupervisedSampler object."
+            )
diff --git a/stellargraph/mapper/node_mappers.py b/stellargraph/mapper/node_mappers.py
old mode 100644
new mode 100755
index af5e242fd..30cb39ba1
--- a/stellargraph/mapper/node_mappers.py
+++ b/stellargraph/mapper/node_mappers.py
@@ -22,6 +22,7 @@
     "NodeSequence",
     "GraphSAGENodeGenerator",
     "HinSAGENodeGenerator",
+    "Attri2VecNodeGenerator",
     "FullBatchNodeGenerator",
     "FullBatchNodeSequence",
     "SparseFullBatchNodeSequence",
@@ -56,17 +57,22 @@ class NodeSequence(Sequence):
 
     This class generated data samples for node inference models
     and should be created using the `.flow(...)` method of
-    :class:`GraphSAGENodeGenerator` or :class:`HinSAGENodeGenerator`.
-
-    These Generators are classes that capture the graph structure
-    and the feature vectors of each node. These generator classes
-    are used within the NodeSequence to generate samples of k-hop
-    neighbourhoods in the graph and to return to this class the
-    features from the sampled neighbourhoods.
+    :class:`GraphSAGENodeGenerator` or :class:`DirectedGraphSAGENodeGenerator` 
+    or :class:`HinSAGENodeGenerator` or :class:`Attri2VecNodeGenerator`.
+
+    GraphSAGENodeGenerator, DirectedGraphSAGENodeGenerator,and HinSAGENodeGenerator 
+    are classes that capture the graph structure and the feature vectors of each node. 
+    These generator classes are used within the NodeSequence to generate
+    samples of k-hop neighbourhoods in the graph and to return to this 
+    class the features from the sampled neighbourhoods.
+    
+    Attri2VecNodeGenerator is the class that captures node feature vectors
+    of each node.
 
     Args:
-        generator: GraphSAGENodeGenerator or HinSAGENodeGenerator
-            The generator object containing the graph information.
+        generator: GraphSAGENodeGenerator, DirectedGraphSAGENodeGenerator or 
+            HinSAGENodeGenerator or Attri2VecNodeGenerator. The generator object 
+            containing the graph information.
         ids: list
             A list of the node_ids to be used as head-nodes in the
             downstream task.
@@ -101,22 +107,21 @@ def __init__(self, generator, ids, targets=None, shuffle=True):
                 "Head nodes supplied to generator contain IDs not found in graph"
             )
 
-        # Infer head_node_type
+        # Store the generator to draw samples from graph
         if (
-            generator.schema.node_type_map is None
-            or generator.schema.edge_type_map is None
+            isinstance(generator, GraphSAGENodeGenerator)
+            or isinstance(generator, DirectedGraphSAGENodeGenerator)
+            or isinstance(generator, HinSAGENodeGenerator)
+            or isinstance(generator, Attri2VecNodeGenerator)
         ):
-            raise RuntimeError("Schema must have node and edge type maps.")
+            self.generator = generator
         else:
-            head_node_types = {generator.schema.get_node_type(n) for n in ids}
-        if len(head_node_types) > 1:
-            raise ValueError(
-                "Only a single head node type is currently supported for HinSAGE models"
+            raise TypeError(
+                "({}) GraphSAGENodeGenerator, DirectedGraphSAGENodeGenerator, HinSAGENodeGenerator or Attri2VecNodeGenerator is required.".format(
+                    type(self).__name__
+                )
             )
-        head_node_type = head_node_types.pop()
 
-        # Store the generator to draw samples from graph
-        self.generator = generator
         self.ids = list(ids)
         self.data_size = len(self.ids)
         self.shuffle = shuffle
@@ -124,13 +129,32 @@ def __init__(self, generator, ids, targets=None, shuffle=True):
         # Shuffle IDs to start
         self.on_epoch_end()
 
-        # Save head node type and generate sampling schema
-        self.head_node_types = [head_node_type]
-        ### Experimental; for directed sampling
-        num_samples = getattr(generator, "num_samples", [])
-        self._sampling_schema = generator.schema.sampling_layout(
-            self.head_node_types, num_samples
-        )
+        if (
+            isinstance(self.generator, GraphSAGENodeGenerator)
+            or isinstance(self.generator, DirectedGraphSAGENodeGenerator)
+            or isinstance(self.generator, HinSAGENodeGenerator)
+        ):
+            # Infer head_node_type
+            if (
+                generator.schema.node_type_map is None
+                or generator.schema.edge_type_map is None
+            ):
+                raise RuntimeError("Schema must have node and edge type maps.")
+            else:
+                head_node_types = {generator.schema.get_node_type(n) for n in ids}
+            if len(head_node_types) > 1:
+                raise ValueError(
+                    "Only a single head node type is currently supported for HinSAGE models"
+                )
+            head_node_type = head_node_types.pop()
+
+            # Save head node type and generate sampling schema
+            self.head_node_types = [head_node_type]
+            ### Experimental; for directed sampling
+            num_samples = getattr(generator, "num_samples", [])
+            self._sampling_schema = generator.schema.sampling_layout(
+                self.head_node_types, num_samples
+            )
 
     def __len__(self):
         """Denotes the number of batches per epoch"""
@@ -164,8 +188,16 @@ def __getitem__(self, batch_num):
         # Get corresponding targets
         batch_targets = None if self.targets is None else self.targets[batch_indices]
 
-        # Get sampled nodes
-        batch_feats = self.generator.sample_features(head_ids, self._sampling_schema)
+        if isinstance(self.generator, GraphSAGENodeGenerator) or isinstance(
+            self.generator, HinSAGENodeGenerator
+        ):
+            # Get sampled nodes for GraphSAGENodeGenerator and HinSAGENodeGenerator
+            batch_feats = self.generator.sample_features(
+                head_ids, self._sampling_schema
+            )
+        else:
+            # Get sampled nodes for Attri2VecNodeGenerator
+            batch_feats = self.generator.sample_features(head_ids)
 
         return batch_feats, batch_targets
 
@@ -297,7 +329,7 @@ def flow(self, node_ids, targets=None, shuffle=False):
         supplied node_ids to be used by the downstream task. They should
         be given in the same order as the list of node IDs.
         If they are not specified (for example, for use in prediction),
-        the targets will not be available to the downsteam task.
+        the targets will not be available to the downstream task.
 
         Note that the shuffle argument should be True for training and
         False for prediction.
@@ -461,7 +493,7 @@ def flow(self, node_ids, targets=None, shuffle=False):
         supplied node_ids to be used by the downstream task. They should
         be given in the same order as the list of node IDs.
         If they are not specified (for example, for use in prediction),
-        the targets will not be available to the downsteam task.
+        the targets will not be available to the downstream task.
 
         Note that the shuffle argument should be True for training and
         False for prediction.
@@ -505,6 +537,93 @@ def flow_from_dataframe(self, node_targets, shuffle=False):
         )
 
 
+class Attri2VecNodeGenerator:
+    """
+    A node feature generator for node representation prediction with the 
+    attri2vec model.
+
+    At minimum, supply the StellarGraph and the batch size.
+
+    The supplied graph should be a StellarGraph object that is ready for
+    machine learning. Currently the model requires node features for all
+    nodes in the graph.
+
+    Use the :meth:`flow` method supplying the nodes to get an object 
+    that can be used as a Keras data generator.
+
+    Example::
+
+        G_generator = Attri2VecNodeGenerator(G, 50)
+        data_gen = G_generator.flow(node_ids)
+
+    Args:
+        G (StellarGraph): The machine-learning ready graph.
+        batch_size (int): Size of batch to return.
+        name (str or None): Name of the generator (optional).
+    """
+
+    def __init__(self, G, batch_size, name=None):
+        if not isinstance(G, StellarGraphBase):
+            raise TypeError("Graph must be a StellarGraph object.")
+
+        self.graph = G
+        self.batch_size = batch_size
+        self.name = name
+
+        # Check if the graph has features
+        G.check_graph_for_ml()
+
+    def sample_features(self, head_nodes):
+        """
+        Sample content features of the head nodes, and return these as a list of feature 
+        arrays for the attri2vec algorithm.
+
+        Args:
+            head_nodes: An iterable of head nodes to perform sampling on.
+
+        Returns:
+            A list of feature arrays, with each element being the feature of a
+            head node.
+        """
+
+        batch_feats = self.graph.get_feature_for_nodes(head_nodes)
+        return batch_feats
+
+    def flow(self, node_ids):
+        """
+        Creates a generator/sequence object for node representation prediction
+        with the supplied node ids.
+
+        The node IDs are the nodes to inference on: the embeddings
+        calculated for these nodes are passed to the downstream task. These
+        are a subset/all of the nodes in the graph.
+
+        Args:
+            node_ids: an iterable of node IDs.
+
+        Returns:
+            A NodeSequence object to use with the Attri2Vec model
+            in the Keras method ``predict_generator``.
+
+        """
+        return NodeSequence(self, node_ids, shuffle=False)
+
+    def flow_from_dataframe(self, node_ids):
+        """
+        Creates a generator/sequence object for node representation prediction
+        with the supplied node ids.
+
+        Args:
+            node_ids: a Pandas DataFrame of node_ids.
+
+        Returns:
+            A NodeSequence object to use with the Attri2Vec model
+            in the Keras method ``predict_generator``.
+
+        """
+        return NodeSequence(self, node_ids.index)
+
+
 class SparseFullBatchNodeSequence(Sequence):
     """
     Keras-compatible data generator for for node inference models
@@ -944,7 +1063,7 @@ def flow(self, node_ids, targets=None, shuffle=False):
         supplied node_ids to be used by the downstream task. They should
         be given in the same order as the list of node IDs.
         If they are not specified (for example, for use in prediction),
-        the targets will not be available to the downsteam task.
+        the targets will not be available to the downstream task.
 
         Note that the shuffle argument should be True for training and
         False for prediction.
diff --git a/tests/core/test_stellargraph.py b/tests/core/test_stellargraph.py
index e0cfdb2ad..0b05932ca 100644
--- a/tests/core/test_stellargraph.py
+++ b/tests/core/test_stellargraph.py
@@ -221,6 +221,24 @@ def test_digraph_schema():
         schema.get_edge_type((0, 4, 0))
 
 
+def test_get_index_for_nodes():
+    sg = example_stellar_graph_1(feature_name="feature", feature_size=8)
+    aa = sg.get_index_for_nodes([1, 2, 3, 4])
+    assert aa == [0, 1, 2, 3]
+
+    sg = example_hin_1(feature_name="feature")
+    aa = sg.get_index_for_nodes([0, 1, 2, 3])
+    assert aa == [0, 1, 2, 3]
+    aa = sg.get_index_for_nodes([0, 1, 2, 3], "A")
+    assert aa == [0, 1, 2, 3]
+    aa = sg.get_index_for_nodes([4, 5, 6])
+    assert aa == [0, 1, 2]
+    aa = sg.get_index_for_nodes([4, 5, 6], "B")
+    assert aa == [0, 1, 2]
+    with pytest.raises(ValueError):
+        aa = sg.get_index_for_nodes([1, 2, 5])
+
+
 def test_feature_conversion_from_nodes():
     sg = example_stellar_graph_1(feature_name="feature", feature_size=8)
     aa = sg.get_feature_for_nodes([1, 2, 3, 4])
diff --git a/tests/layer/test_attri2vec.py b/tests/layer/test_attri2vec.py
new file mode 100644
index 000000000..70b7f9f1b
--- /dev/null
+++ b/tests/layer/test_attri2vec.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2018 Data61, CSIRO
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Attri2Vec tests
+
+"""
+from stellargraph.core.graph import StellarGraph
+from stellargraph.mapper.node_mappers import Attri2VecNodeGenerator
+from stellargraph.layer.attri2vec import *
+
+from tensorflow import keras
+import numpy as np
+import networkx as nx
+import pytest
+
+
+def example_graph_1(feature_size=None):
+    G = nx.Graph()
+    elist = [(1, 2), (2, 3), (1, 4), (3, 2)]
+    G.add_nodes_from([1, 2, 3, 4], label="default")
+    G.add_edges_from(elist, label="default")
+
+    # Add example features
+    if feature_size is not None:
+        for v in G.nodes():
+            G.node[v]["feature"] = np.ones(feature_size)
+        return StellarGraph(G, node_features="feature")
+
+    else:
+        return StellarGraph(G)
+
+
+def test_attri2vec_constructor():
+    attri2vec = Attri2Vec(layer_sizes=[4], input_dim=2, node_num=4, normalize="l2")
+    assert attri2vec.dims == [2, 4]
+    assert attri2vec.input_node_num == 4
+    assert attri2vec.n_layers == 1
+    assert attri2vec.bias == False
+
+    # Check incorrect activation flag
+    with pytest.raises(ValueError):
+        Attri2Vec(layer_sizes=[4], input_dim=2, node_num=4, activation="unknown")
+
+    # Check incorrect normalization flag
+    with pytest.raises(ValueError):
+        Attri2Vec(layer_sizes=[4], input_dim=2, node_num=4, normalize=lambda x: x)
+
+    with pytest.raises(ValueError):
+        Attri2Vec(layer_sizes=[4], input_dim=2, node_num=4, normalize="unknown")
+
+    # Check requirement for generator or input_dim and node_num
+    with pytest.raises(RuntimeError):
+        Attri2Vec(layer_sizes=[4])
+
+    # Construction from generator
+    G = example_graph_1(feature_size=3)
+    gen = Attri2VecNodeGenerator(G, batch_size=2).flow([1, 2])
+    attri2vec = Attri2Vec(layer_sizes=[4, 8], generator=gen, bias=True)
+
+    assert attri2vec.dims == [3, 4, 8]
+    assert attri2vec.input_node_num == 4
+    assert attri2vec.n_layers == 2
+    assert attri2vec.bias
+
+
+def test_attri2vec_apply():
+    attri2vec = Attri2Vec(
+        layer_sizes=[2, 2, 2],
+        bias=False,
+        input_dim=2,
+        node_num=4,
+        activation="linear",
+        normalize=None,
+    )
+
+    x = np.array([[1, 2]])
+    expected = np.array([[12, 12]])
+
+    inp = keras.Input(shape=(2,))
+    out = attri2vec(inp)
+    model1 = keras.Model(inputs=inp, outputs=out)
+    model_weights1 = [np.ones_like(w) for w in model1.get_weights()]
+    model1.set_weights(model_weights1)
+    actual = model1.predict(x)
+    assert expected == pytest.approx(actual)
+
+    # Use the node model:
+    xinp, xout = attri2vec.node_model()
+    model2 = keras.Model(inputs=xinp, outputs=xout)
+    model_weights2 = [np.ones_like(w) for w in model2.get_weights()]
+    model2.set_weights(model_weights2)
+    assert pytest.approx(expected) == model2.predict(x)
+
+    x1 = np.array([[3, 1]])
+    x2 = np.array([[2]])
+    y1 = np.array([[16, 16]])
+    y2 = np.array([[1, 1]])
+
+    # Test the build function:
+    xinp, xout = attri2vec.build()
+    model3 = keras.Model(inputs=xinp, outputs=xout)
+    model_weights3 = [np.ones_like(w) for w in model3.get_weights()]
+    model3.set_weights(model_weights3)
+    actual = model3.predict([x1, x2])
+    assert pytest.approx(y1) == actual[0]
+    assert pytest.approx(y2) == actual[1]
+
+    # Use the link model:
+    xinp, xout = attri2vec.link_model()
+    model4 = keras.Model(inputs=xinp, outputs=xout)
+    model_weights4 = [np.ones_like(w) for w in model4.get_weights()]
+    model4.set_weights(model_weights4)
+    actual = model4.predict([x1, x2])
+    assert pytest.approx(y1) == actual[0]
+    assert pytest.approx(y2) == actual[1]
+
+
+def test_attri2vec_serialize():
+    attri2vec = Attri2Vec(
+        layer_sizes=[4],
+        bias=False,
+        input_dim=2,
+        node_num=4,
+        activation="linear",
+        normalize=None,
+    )
+
+    inp = keras.Input(shape=(2,))
+    out = attri2vec(inp)
+    model = keras.Model(inputs=inp, outputs=out)
+
+    # Save model
+    model_json = model.to_json()
+
+    # Set all weights to one
+    model_weights = [np.ones_like(w) for w in model.get_weights()]
+
+    # Load model from json & set all weights
+    model2 = keras.models.model_from_json(model_json)
+    model2.set_weights(model_weights)
+
+    # Test loaded model
+    x = np.array([[1, 2]])
+    expected = np.array([[3, 3, 3, 3]])
+
+    actual = model2.predict(x)
+    assert expected == pytest.approx(actual)
diff --git a/tests/mapper/test_link_mappers.py b/tests/mapper/test_link_mappers.py
old mode 100644
new mode 100755
index 7a033a623..a06c34b6e
--- a/tests/mapper/test_link_mappers.py
+++ b/tests/mapper/test_link_mappers.py
@@ -695,3 +695,147 @@ def test_HinSAGELinkGenerator_isolates(self):
 
         # With two isolates, all features are zero
         assert all(pytest.approx(0) == x for x in ne[2:])
+
+
+class Test_Attri2VecLinkGenerator:
+    """
+    Tests of Attri2VecLinkGenerator class
+    """
+
+    n_feat = 4
+    batch_size = 2
+
+    def test_LinkMapper_constructor(self):
+
+        G = example_Graph_1(self.n_feat)
+        edge_labels = [0] * G.number_of_edges()
+
+        generator = Attri2VecLinkGenerator(G, batch_size=self.batch_size)
+        mapper = generator.flow(G.edges(), edge_labels)
+        assert generator.batch_size == self.batch_size
+        assert mapper.data_size == G.number_of_edges()
+        assert len(mapper.ids) == G.number_of_edges()
+
+        G = example_DiGraph_1(self.n_feat)
+        edge_labels = [0] * G.number_of_edges()
+        generator = Attri2VecLinkGenerator(G, batch_size=self.batch_size)
+        mapper = generator.flow(G.edges(), edge_labels)
+        assert generator.batch_size == self.batch_size
+        assert mapper.data_size == G.number_of_edges()
+        assert len(mapper.ids) == G.number_of_edges()
+
+    def test_Attri2VecLinkGenerator_1(self):
+
+        G = example_Graph_2(self.n_feat)
+        data_size = G.number_of_edges()
+        edge_labels = [0] * data_size
+
+        mapper = Attri2VecLinkGenerator(G, batch_size=self.batch_size).flow(
+            G.edges(), edge_labels
+        )
+
+        assert len(mapper) == 2
+
+        for batch in range(len(mapper)):
+            nf, nl = mapper[batch]
+            assert len(nf) == 2
+            assert nf[0].shape == (min(self.batch_size, data_size), self.n_feat)
+            assert nf[1].shape == (min(self.batch_size, data_size),)
+            assert len(nl) == min(self.batch_size, data_size)
+            assert all(nl == 0)
+
+        with pytest.raises(IndexError):
+            nf, nl = mapper[2]
+
+    def test_edge_consistency(self):
+        G = example_Graph_2(1)
+        edges = list(G.edges())
+        nodes = list(G.nodes())
+        edge_labels = list(range(len(edges)))
+
+        mapper = Attri2VecLinkGenerator(G, batch_size=2).flow(edges, edge_labels)
+
+        assert len(mapper) == 2
+
+        for batch in range(len(mapper)):
+            nf, nl = mapper[batch]
+            e1 = edges[nl[0]]
+            e2 = edges[nl[1]]
+            assert nf[0][0, 0] == e1[0]
+            assert nf[1][0] == nodes.index(e1[1])
+            assert nf[0][1, 0] == e2[0]
+            assert nf[1][1] == nodes.index(e2[1])
+
+    def test_Attri2VecLinkGenerator_not_Stellargraph(self):
+        G = nx.Graph()
+        elist = [(1, 2), (2, 3), (1, 4), (3, 2)]
+        G.add_edges_from(elist)
+
+        # Add example features
+        for v in G.nodes():
+            G.node[v]["feature"] = np.ones(1)
+
+        with pytest.raises(TypeError):
+            Attri2VecLinkGenerator(G, batch_size=self.batch_size)
+
+    def test_Attri2VecLinkGenerator_no_targets(self):
+        """
+        This tests link generator's iterator for prediction, i.e., without targets provided
+        """
+        G = example_Graph_2(self.n_feat)
+        gen = Attri2VecLinkGenerator(G, batch_size=self.batch_size).flow(G.edges())
+        for i in range(len(gen)):
+            assert gen[i][1] is None
+
+    def test_Attri2VecLinkGenerator_unsupervisedSampler_flow(self):
+        """
+        This tests link generator's initialization for on demand link generation i.e. there is no pregenerated list of samples provided to it.
+        """
+        n_feat = 4
+        n_batch = 2
+
+        # test graph
+        G = example_graph_random(
+            feature_size=n_feat, n_nodes=6, n_isolates=2, n_edges=10
+        )
+
+        unsupervisedSamples = UnsupervisedSampler(G, nodes=G.nodes)
+
+        gen = Attri2VecLinkGenerator(G, batch_size=n_batch).flow(unsupervisedSamples)
+
+        # The flow method is not passed UnsupervisedSampler object or a list of samples is not passed
+        with pytest.raises(TypeError):
+            gen = Attri2VecLinkGenerator(G, batch_size=n_batch).flow(
+                "not_a_list_of_samples_or_a_sample_generator"
+            )
+
+        # The flow method is not passed nothing
+        with pytest.raises(TypeError):
+            gen = Attri2VecLinkGenerator(G, batch_size=n_batch).flow()
+
+    def test_Attri2VecLinkGenerator_unsupervisedSampler_sample_generation(self):
+
+        G = example_Graph_2(self.n_feat)
+
+        unsupervisedSamples = UnsupervisedSampler(G)
+
+        mapper = Attri2VecLinkGenerator(G, batch_size=self.batch_size).flow(
+            unsupervisedSamples
+        )
+
+        assert mapper.data_size == 16
+        assert self.batch_size == 2
+        assert len(mapper) == 8
+
+        for batch in range(len(mapper)):
+            nf, nl = mapper[batch]
+
+            assert len(nf) == 2
+
+            assert nf[0].shape == (min(self.batch_size, mapper.data_size), self.n_feat)
+            assert nf[1].shape == (min(self.batch_size, mapper.data_size),)
+            assert len(nl) == min(self.batch_size, mapper.data_size)
+            assert sorted(nl) == [0, 1]
+
+        with pytest.raises(IndexError):
+            nf, nl = mapper[8]
diff --git a/tests/mapper/test_node_mappers.py b/tests/mapper/test_node_mappers.py
old mode 100644
new mode 100755
index 39c66dc24..f7b7ef2b2
--- a/tests/mapper/test_node_mappers.py
+++ b/tests/mapper/test_node_mappers.py
@@ -682,6 +682,91 @@ def test_hinnodemapper_no_neighbors():
     assert np.all(batch_feats[3][:, 0, 0] == np.array([12, 0, 0]))
 
 
+def test_attri2vec_nodemapper_constructor_nx():
+    """
+    Attri2VecNodeGenerator requires a StellarGraph object
+    """
+    G = nx.Graph()
+    G.add_nodes_from(range(4))
+
+    with pytest.raises(TypeError):
+        Attri2VecNodeGenerator(G, batch_size=2)
+
+
+def test_attri2vec_nodemapper_constructor_no_feats():
+    """
+    Attri2VecNodeGenerator requires the graph to have features
+    """
+
+    G = example_graph_1()
+    with pytest.raises(RuntimeError):
+        Attri2VecNodeGenerator(G, batch_size=2)
+
+
+def test_attri2vec_nodemapper_constructor():
+    n_feat = 4
+
+    G = example_graph_1(feature_size=n_feat)
+
+    generator = Attri2VecNodeGenerator(G, batch_size=2)
+
+    mapper = generator.flow(list(G))
+
+    assert generator.batch_size == 2
+    assert mapper.data_size == 4
+    assert len(mapper.ids) == 4
+
+
+def test_attri2vec_nodemapper_1():
+    n_feat = 4
+    n_batch = 2
+
+    # test graph
+    G1 = example_graph_1(n_feat)
+
+    mapper1 = Attri2VecNodeGenerator(G1, batch_size=n_batch).flow(G1.nodes())
+    assert len(mapper1) == 2
+
+    G2 = example_graph_2(n_feat)
+
+    mapper2 = Attri2VecNodeGenerator(G2, batch_size=n_batch).flow(G2.nodes())
+    assert len(mapper2) == 3
+
+    for mapper in [mapper1, mapper2]:
+        for ii in range(2):
+            nf, nl = mapper[ii]
+            assert nf.shape == (n_batch, n_feat)
+            assert nl is None
+
+    # Check beyond the graph lengh
+    with pytest.raises(IndexError):
+        nf, nl = mapper1[len(mapper1)]
+
+    # Check the last batch
+    nf, nl = mapper2[len(mapper2) - 1]
+    assert nf.shape == (1, n_feat)
+
+    # This will fail as the nodes are not in the graph
+    with pytest.raises(KeyError):
+        Attri2VecNodeGenerator(G1, batch_size=2).flow(["A", "B"])
+
+
+def test_attri2vec_nodemapper_2():
+    n_feat = 1
+    n_batch = 2
+
+    G = example_graph_2(feature_size=n_feat)
+    nodes = list(G.nodes())
+
+    # With no shuffle
+    mapper = Attri2VecNodeGenerator(G, batch_size=n_batch).flow(nodes)
+    expected_node_batches = [[1, 2], [3, 4], [5]]
+    assert len(mapper) == 3
+    for ii in range(len(mapper)):
+        nf, nl = mapper[ii]
+        assert all(np.ravel(nf) == expected_node_batches[ii])
+
+
 def create_graph_features():
     G = nx.Graph()
     G.add_nodes_from(["a", "b", "c"])