files for doctest

Author: autoih

tensorflow_addons/layers/wrappers.py

@@ -30,21 +30,25 @@ class WeightNormalization(tf.keras.layers.Wrapper):
     Training of Deep Neural Networks: https://arxiv.org/abs/1602.07868
     Tim Salimans, Diederik P. Kingma (2016)
     WeightNormalization wrapper works for keras and tf layers.
-    ```python
-      net = WeightNormalization(
-          tf.keras.layers.Conv2D(2, 2, activation='relu'),
-          input_shape=(32, 32, 3),
-          data_init=True)(x)
-      net = WeightNormalization(
-          tf.keras.layers.Conv2D(16, 5, activation='relu'),
-          data_init=True)(net)
-      net = WeightNormalization(
-          tf.keras.layers.Dense(120, activation='relu'),
-          data_init=True)(net)
-      net = WeightNormalization(
-          tf.keras.layers.Dense(n_classes),
-          data_init=True)(net)
-    ```
+
+    Usage: 
+
+    >>> net = tfa.layers.WeightNormalization(
+    ...   tf.keras.layers.Conv2D(2, 2, activation='relu'),
+    ...   input_shape=(32, 32, 3),
+    ...   data_init=True)(np.random.rand(32, 32, 3, 1).astype('f'))
+    >>> net = tfa.layers.WeightNormalization(
+    ...   tf.keras.layers.Conv2D(16, 2, activation='relu'),
+    ...   data_init=True)(net)
+    >>> net = tfa.layers.WeightNormalization(
+    ...   tf.keras.layers.Dense(120, activation='relu'),
+    ...   data_init=True)(net)
+    >>> net = tfa.layers.WeightNormalization(
+    ...   tf.keras.layers.Dense(2),
+    ...   data_init=True)(net)
+    >>> net.shape
+    TensorShape([32, 30, 1, 2])
+
     Arguments:
       layer: a layer instance.
       data_init: If `True` use data dependent variable initialization

tensorflow_addons/losses/focal_loss.py

@@ -37,15 +37,14 @@ class SigmoidFocalCrossEntropy(tf.keras.losses.Loss):
 
     Usage:
 
-    ```python
-    fl = tfa.losses.SigmoidFocalCrossEntropy()
-    loss = fl(
-      [[0.97], [0.91], [0.03]],
-      [[1.0], [1.0], [0.0]])
-    print('Loss: ', loss.numpy())  # Loss: [[0.00010971]
-                                            [0.0032975]
-                                            [0.00030611]]
-    ```
+    >>> fl = tfa.losses.SigmoidFocalCrossEntropy()
+    >>> loss = fl([[0.97], [0.91], [0.03]], [[1.0], [1.0], [0.0]])
+    >>> loss
+    <tf.Tensor: shape=(3, 1), dtype=float32, numpy=
+    array([[0.00010971],
+           [0.0032975 ],
+           [0.00030611]], dtype=float32)>
+
     Usage with tf.keras API:
 
     ```python
@@ -65,7 +64,7 @@ class SigmoidFocalCrossEntropy(tf.keras.losses.Loss):
         ValueError: If the shape of `sample_weight` is invalid or value of
           `gamma` is less than zero
     """
-
+    
     def __init__(self,
                  from_logits=False,
                  alpha=0.25,

tensorflow_addons/losses/giou_loss.py

@@ -33,13 +33,13 @@ class GIoULoss(tf.keras.losses.Loss):
 
     Usage:
 
-    ```python
-    gl = tfa.losses.GIoULoss()
-    boxes1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
-    boxes2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0]])
-    loss = gl(boxes1, boxes2)
-    print('Loss: ', loss.numpy())  # Loss: [1.07500000298023224, 1.9333333373069763]
-    ```
+    >>> gl = tfa.losses.GIoULoss()
+    >>> boxes1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+    >>> boxes2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0]])
+    >>> loss = gl(boxes1, boxes2)
+    >>> loss
+    <tf.Tensor: shape=(), dtype=float32, numpy=1.5041667>
+
     Usage with tf.keras API:
 
     ```python

tensorflow_addons/metrics/matthews_correlation_coefficient.py

@@ -42,20 +42,16 @@ class MatthewsCorrelationCoefficient(tf.keras.metrics.Metric):
           ((TP + FP) * (TP + FN) * (TN + FP ) * (TN + FN))^(1/2)
 
     Usage:
-    ```python
-    actuals = tf.constant([[1.0], [1.0], [1.0], [0.0]],
-             dtype=tf.float32)
-    preds = tf.constant([[1.0], [0.0], [1.0], [1.0]],
-             dtype=tf.float32)
-    # Matthews correlation coefficient
-    mcc = MatthewsCorrelationCoefficient(num_classes=1)
-    mcc.update_state(actuals, preds)
-    print('Matthews correlation coefficient is:',
-    mcc.result().numpy())
-    # Matthews correlation coefficient is : -0.33333334
-    ```
-    """
 
+    >>> actuals = tf.constant([[1.0], [1.0], [1.0], [0.0]], dtype=tf.float32)
+    >>> preds = tf.constant([[1.0], [0.0], [1.0], [1.0]], dtype=tf.float32)
+    >>> mcc = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=1)
+    >>> mcc.update_state(actuals, preds)
+    >>> mcc.result()
+    <tf.Tensor: shape=(1,), dtype=float32, numpy=array([-0.33333334], dtype=float32)>
+
+    """
+    
     def __init__(self,
                  num_classes=None,
                  name='MatthewsCorrelationCoefficient',

tensorflow_addons/metrics/multilabel_confusion_matrix.py

@@ -44,32 +44,30 @@ class MultiLabelConfusionMatrix(Metric):
     - false negatives for class i in M(1,0)
     - true positives for class i in M(1,1)
 
-    ```python
+    Usage:
+    
     # multilabel confusion matrix
-    y_true = tf.constant([[1, 0, 1], [0, 1, 0]],
-             dtype=tf.int32)
-    y_pred = tf.constant([[1, 0, 0],[0, 1, 1]],
-             dtype=tf.int32)
-    output = MultiLabelConfusionMatrix(num_classes=3)
-    output.update_state(y_true, y_pred)
-    print('Confusion matrix:', output.result().numpy())
-
-    # Confusion matrix: [[[1 0] [0 1]] [[1 0] [0 1]]
-                      [[0 1] [1 0]]]
+    >>> y_true = tf.constant([[1, 0, 1], [0, 1, 0]], dtype=tf.int32)
+    >>> y_pred = tf.constant([[1, 0, 0],[0, 1, 1]], dtype=tf.int32)
+    >>> output = tfa.metrics.MultiLabelConfusionMatrix(num_classes=3)
+    >>> output.update_state(y_true, y_pred)
+    >>> output.result()
+    <tf.Tensor: shape=(3, 2, 2), dtype=int32, numpy=
+    array([[[1, 0], [0, 1]], [[1, 0], [0, 1]], [[0, 1],
+    [1, 0]]], dtype=int32)>
 
     # if multiclass input is provided
-    y_true = tf.constant([[1, 0, 0], [0, 1, 0]],
-             dtype=tf.int32)
-    y_pred = tf.constant([[1, 0, 0],[0, 0, 1]],
-             dtype=tf.int32)
-    output = MultiLabelConfusionMatrix(num_classes=3)
-    output.update_state(y_true, y_pred)
-    print('Confusion matrix:', output.result().numpy())
-
-    # Confusion matrix: [[[1 0] [0 1]] [[1 0] [1 0]] [[1 1] [0 0]]]
-    ```
+    >>> y_true = tf.constant([[1, 0, 0], [0, 1, 0]], dtype=tf.int32)
+    >>> y_pred = tf.constant([[1, 0, 0],[0, 0, 1]], dtype=tf.int32)
+    >>> output = tfa.metrics.MultiLabelConfusionMatrix(num_classes=3)
+    >>> output.update_state(y_true, y_pred)
+    >>> output.result()
+    <tf.Tensor: shape=(3, 2, 2), dtype=int32, numpy=
+    array([[[1, 0], [0, 1]], [[1, 0], [1, 0]], [[1, 1], [0, 0]]], 
+    dtype=int32)>
+    
     """
-
+    
     def __init__(self,
                  num_classes,
                  name='Multilabel_confusion_matrix',

tensorflow_addons/metrics/r_square.py

@@ -35,15 +35,16 @@ class RSquare(Metric):
      - It can also be negative if the model is worse.
 
      Usage:
-     ```python
-     actuals = tf.constant([1, 4, 3], dtype=tf.float32)
-     preds = tf.constant([2, 4, 4], dtype=tf.float32)
-     result = tf.keras.metrics.RSquare()
-     result.update_state(actuals, preds)
-     print('R^2 score is: ', r1.result().numpy()) # 0.57142866
-    ```
-    """
 
+    >>> actuals = tf.constant([1, 4, 3], dtype=tf.float32)
+    >>> preds = tf.constant([2, 4, 4], dtype=tf.float32)
+    >>> ans = tfa.metrics.RSquare()
+    >>> ans.update_state(actuals, preds)
+    >>> ans.result()
+    <tf.Tensor: shape=(), dtype=float32, numpy=0.57142866>
+     
+    """
+    
     def __init__(self, name='r_square', dtype=tf.float32):
         super(RSquare, self).__init__(name=name, dtype=dtype)
         self.squared_sum = self.add_weight("squared_sum", initializer="zeros")

tensorflow_addons/optimizers/lookahead.py

@@ -35,10 +35,9 @@ class Lookahead(tf.keras.optimizers.Optimizer):
 
     Example of usage:
 
-    ```python
-    opt = tf.keras.optimizers.SGD(learning_rate)
-    opt = tfa.optimizers.Lookahead(opt)
-    ```
+    >>> opt = tf.keras.optimizers.SGD(learning_rate=0.01)
+    >>> opt = tfa.optimizers.Lookahead(opt)
+    
     """
 
     def __init__(self,

tensorflow_addons/optimizers/moving_average.py

@@ -32,11 +32,9 @@ class MovingAverage(tf.keras.optimizers.Optimizer):
 
     Example of usage:
 
-    ```python
-    opt = tf.keras.optimizers.SGD(learning_rate)
-    opt = tfa.optimizers.MovingAverage(opt)
+    >>> opt = tf.keras.optimizers.SGD(learning_rate=0.01)
+    >>> opt = tfa.optimizers.MovingAverage(opt)
 
-    ```
     """
 
     def __init__(self,

tensorflow_addons/optimizers/weight_decay_optimizers.py

@@ -54,18 +54,15 @@ def __init__(self, weight_decay, *args, **kwargs):
     Note: when applying a decay to the learning rate, be sure to manually apply
     the decay to the `weight_decay` as well. For example:
 
-    ```python
-    step = tf.Variable(0, trainable=False)
-    schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
-        [10000, 15000], [1e-0, 1e-1, 1e-2])
-    # lr and wd can be a function or a tensor
-    lr = 1e-1 * schedule(step)
-    wd = lambda: 1e-4 * schedule(step)
-
-    # ...
-
-    optimizer = tfa.optimizers.AdamW(learning_rate=lr, weight_decay=wd)
-    ```
+    Usage:
+
+    >>> step = tf.Variable(0, trainable=False)
+    >>> schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
+    ... [10000, 15000], [1e-0, 1e-1, 1e-2])
+    >>> lr = 1e-1 * schedule(step)
+    >>> wd = lambda: 1e-4 * schedule(step)
+    >>> optimizer = tfa.optimizers.AdamW(learning_rate=lr, weight_decay=wd)
+    
     """
 
     def __init__(self, weight_decay, **kwargs):
@@ -213,18 +210,15 @@ def extend_with_decoupled_weight_decay(base_optimizer):
     Note: when applying a decay to the learning rate, be sure to manually apply
     the decay to the `weight_decay` as well. For example:
 
-    ```python
-    step = tf.Variable(0, trainable=False)
-    schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
-        [10000, 15000], [1e-0, 1e-1, 1e-2])
-    # lr and wd can be a function or a tensor
-    lr = 1e-1 * schedule(step)
-    wd = lambda: 1e-4 * schedule(step)
+    Usage: 
 
-    # ...
+    >>> step = tf.Variable(0, trainable=False)
+    >>> schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
+    ... [10000, 15000], [1e-0, 1e-1, 1e-2])
+    >>> lr = 1e-1 * schedule(step)
+    >>> wd = lambda: 1e-4 * schedule(step)
+    >>> optimizer = tfa.optimizers.AdamW(learning_rate=lr, weight_decay=wd)
 
-    optimizer = tfa.optimizers.AdamW(learning_rate=lr, weight_decay=wd)
-    ```
 
     Note: you might want to register your own custom optimizer using
     `tf.keras.utils.get_custom_objects()`.
@@ -287,19 +281,16 @@ class SGDW(DecoupledWeightDecayExtension, tf.keras.optimizers.SGD):
     Note: when applying a decay to the learning rate, be sure to manually apply
     the decay to the `weight_decay` as well. For example:
 
-    ```python
-    step = tf.Variable(0, trainable=False)
-    schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
-        [10000, 15000], [1e-0, 1e-1, 1e-2])
-    # lr and wd can be a function or a tensor
-    lr = 1e-1 * schedule(step)
-    wd = lambda: 1e-4 * schedule(step)
-
-    # ...
+    Usage: 
 
-    optimizer = tfa.optimizers.SGDW(
-        learning_rate=lr, weight_decay=wd, momentum=0.9)
-    ```
+    >>> step = tf.Variable(0, trainable=False)
+    >>> schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
+    ... [10000, 15000], [1e-0, 1e-1, 1e-2])
+    >>> lr = 1e-1 * schedule(step)
+    >>> wd = lambda: 1e-4 * schedule(step)
+    >>> optimizer = tfa.optimizers.SGDW(
+    ... learning_rate=lr, weight_decay=wd, momentum=0.9)
+    
     """
 
     def __init__(self,
@@ -362,18 +353,15 @@ class AdamW(DecoupledWeightDecayExtension, tf.keras.optimizers.Adam):
     Note: when applying a decay to the learning rate, be sure to manually apply
     the decay to the `weight_decay` as well. For example:
 
-    ```python
-    step = tf.Variable(0, trainable=False)
-    schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
-        [10000, 15000], [1e-0, 1e-1, 1e-2])
-    # lr and wd can be a function or a tensor
-    lr = 1e-1 * schedule(step)
-    wd = lambda: 1e-4 * schedule(step)
-
-    # ...
+    Usage: 
 
-    optimizer = tfa.optimizers.AdamW(learning_rate=lr, weight_decay=wd)
-    ```
+    >>> step = tf.Variable(0, trainable=False)
+    >>> schedule = tf.optimizers.schedules.PiecewiseConstantDecay(
+    ... [10000, 15000], [1e-0, 1e-1, 1e-2])
+    >>> lr = 1e-1 * schedule(step)
+    >>> wd = lambda: 1e-4 * schedule(step)
+    >>> optimizer = tfa.optimizers.AdamW(learning_rate=lr, weight_decay=wd)
+    
     """
 
     def __init__(self,