solve save model bug and add gcn

Author: dragen1860

.gitignore

@@ -1,4 +1,120 @@
-
 data
 .idea
 tmp
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

lesson28-GCN/README.MD

@@ -0,0 +1,19 @@
+# Graph Convolution Network for TF2
+
+GCN implementation for paper: [Semi-Supervised Classification with Graph Convolutional Networks](https://arxiv.org/pdf/1609.02907.pdf)
+
+# Benchmark
+
+| dataset       | Citeseea | Cora | Pubmed | NELL |
+|---------------|----------|------|--------|------|
+| GCN(official) | 70.3     | 81.5 | 79.0   | 66.0 |
+| This repo.    |          | 81.8 |   78.9  |      |
+
+# HOWTO
+```
+python train.py
+```
+
+# Screenshot
+
+![](res/screen.png)

lesson28-GCN/config.py

@@ -0,0 +1,16 @@
+import  argparse
+
+args = argparse.ArgumentParser()
+args.add_argument('--dataset', default='cora')
+args.add_argument('--model', default='gcn')
+args.add_argument('--learning_rate', default=0.01)
+args.add_argument('--epochs', default=200)
+args.add_argument('--hidden1', default=16)
+args.add_argument('--dropout', default=0.5)
+args.add_argument('--weight_decay', default=5e-4)
+args.add_argument('--early_stopping', default=10)
+args.add_argument('--max_degree', default=3)
+
+
+args = args.parse_args()
+print(args)

lesson28-GCN/inits.py

@@ -0,0 +1,27 @@
+import tensorflow as tf
+import numpy as np
+
+
+def uniform(shape, scale=0.05, name=None):
+    """Uniform init."""
+    initial = tf.random.uniform(shape, minval=-scale, maxval=scale, dtype=tf.float32)
+    return tf.Variable(initial, name=name)
+
+
+def glorot(shape, name=None):
+    """Glorot & Bengio (AISTATS 2010) init."""
+    init_range = np.sqrt(6.0/(shape[0]+shape[1]))
+    initial = tf.random.uniform(shape, minval=-init_range, maxval=init_range, dtype=tf.float32)
+    return tf.Variable(initial, name=name)
+
+
+def zeros(shape, name=None):
+    """All zeros."""
+    initial = tf.zeros(shape, dtype=tf.float32)
+    return tf.Variable(initial, name=name)
+
+
+def ones(shape, name=None):
+    """All ones."""
+    initial = tf.ones(shape, dtype=tf.float32)
+    return tf.Variable(initial, name=name)

lesson28-GCN/layers.py

@@ -0,0 +1,154 @@
+from    inits import *
+import  tensorflow as tf
+from    tensorflow import keras
+from    tensorflow.keras import layers
+from    config import args
+
+
+
+
+# global unique layer ID dictionary for layer name assignment
+_LAYER_UIDS = {}
+
+
+def get_layer_uid(layer_name=''):
+    """Helper function, assigns unique layer IDs."""
+    if layer_name not in _LAYER_UIDS:
+        _LAYER_UIDS[layer_name] = 1
+        return 1
+    else:
+        _LAYER_UIDS[layer_name] += 1
+        return _LAYER_UIDS[layer_name]
+
+
+def sparse_dropout(x, rate, noise_shape):
+    """
+    Dropout for sparse tensors.
+    """
+    random_tensor = 1 - rate
+    random_tensor += tf.random.uniform(noise_shape)
+    dropout_mask = tf.cast(tf.floor(random_tensor), dtype=tf.bool)
+    pre_out = tf.sparse.retain(x, dropout_mask)
+    return pre_out * (1./(1 - rate))
+
+
+def dot(x, y, sparse=False):
+    """
+    Wrapper for tf.matmul (sparse vs dense).
+    """
+    if sparse:
+        res = tf.sparse.sparse_dense_matmul(x, y)
+    else:
+        res = tf.matmul(x, y)
+    return res
+
+
+
+
+class Dense(layers.Layer):
+    """Dense layer."""
+    def __init__(self, input_dim, output_dim, placeholders, dropout=0., sparse_inputs=False,
+                 act=tf.nn.relu, bias=False, featureless=False, **kwargs):
+        super(Dense, self).__init__(**kwargs)
+
+        if dropout:
+            self.dropout = placeholders['dropout']
+        else:
+            self.dropout = 0.
+
+        self.act = act
+        self.sparse_inputs = sparse_inputs
+        self.featureless = featureless
+        self.bias = bias
+
+        # helper variable for sparse dropout
+        self.num_features_nonzero = placeholders['num_features_nonzero']
+
+        with tf.variable_scope(self.name + '_vars'):
+            self.vars['weights'] = glorot([input_dim, output_dim],
+                                          name='weights')
+            if self.bias:
+                self.vars['bias'] = zeros([output_dim], name='bias')
+
+        if self.logging:
+            self._log_vars()
+
+    def _call(self, inputs):
+        x = inputs
+
+        # dropout
+        if self.sparse_inputs:
+            x = sparse_dropout(x, 1-self.dropout, self.num_features_nonzero)
+        else:
+            x = tf.nn.dropout(x, 1-self.dropout)
+
+        # transform
+        output = dot(x, self.vars['weights'], sparse=self.sparse_inputs)
+
+        # bias
+        if self.bias:
+            output += self.vars['bias']
+
+        return self.act(output)
+
+
+class GraphConvolution(layers.Layer):
+    """
+    Graph convolution layer.
+    """
+    def __init__(self, input_dim, output_dim, num_features_nonzero,
+                 dropout=0.,
+                 is_sparse_inputs=False,
+                 activation=tf.nn.relu,
+                 bias=False,
+                 featureless=False, **kwargs):
+        super(GraphConvolution, self).__init__(**kwargs)
+
+        self.dropout = dropout
+        self.activation = activation
+        self.is_sparse_inputs = is_sparse_inputs
+        self.featureless = featureless
+        self.bias = bias
+        self.num_features_nonzero = num_features_nonzero
+
+        self.weights_ = []
+        for i in range(1):
+            w = self.add_variable('weight' + str(i), [input_dim, output_dim])
+            self.weights_.append(w)
+        if self.bias:
+            self.bias = self.add_variable('bias', [output_dim])
+
+
+        # for p in self.trainable_variables:
+        #     print(p.name, p.shape)
+
+
+
+    def call(self, inputs, training=None):
+        x, support_ = inputs
+
+        # dropout
+        if training is not False and self.is_sparse_inputs:
+            x = sparse_dropout(x, self.dropout, self.num_features_nonzero)
+        elif training is not False:
+            x = tf.nn.dropout(x, self.dropout)
+
+
+        # convolve
+        supports = list()
+        for i in range(len(support_)):
+            if not self.featureless: # if it has features x
+                pre_sup = dot(x, self.weights_[i], sparse=self.is_sparse_inputs)
+            else:
+                pre_sup = self.weights_[i]
+
+            support = dot(support_[i], pre_sup, sparse=True)
+            supports.append(support)
+
+        output = tf.add_n(supports)
+
+        # bias
+        if self.bias:
+            output += self.bias
+
+        return self.activation(output)

lesson28-GCN/metrics.py

@@ -0,0 +1,24 @@
+import tensorflow as tf
+
+
+def masked_softmax_cross_entropy(preds, labels, mask):
+    """
+    Softmax cross-entropy loss with masking.
+    """
+    loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)
+    mask = tf.cast(mask, dtype=tf.float32)
+    mask /= tf.reduce_mean(mask)
+    loss *= mask
+    return tf.reduce_mean(loss)
+
+
+def masked_accuracy(preds, labels, mask):
+    """
+    Accuracy with masking.
+    """
+    correct_prediction = tf.equal(tf.argmax(preds, 1), tf.argmax(labels, 1))
+    accuracy_all = tf.cast(correct_prediction, tf.float32)
+    mask = tf.cast(mask, dtype=tf.float32)
+    mask /= tf.reduce_mean(mask)
+    accuracy_all *= mask
+    return tf.reduce_mean(accuracy_all)