Updates based on comments from PR.

Removed generic from Regularizer class and changed the call method to define the generic return based on the weights parameter.
Added static method l1_l2() to L1L2 class.
Fixed JavaDoc comments.

Author: JimClarke5

tensorflow-framework/src/main/java/org/tensorflow/framework/regularizers/L1.java

@@ -15,26 +15,23 @@
 package org.tensorflow.framework.regularizers;
 
 import org.tensorflow.op.Ops;
-import org.tensorflow.types.family.TNumber;
 
 /**
- * A regularizer that applies an L1 or Lasso(least absolute shrinkage and selection operator) Regression,
- * regularization penalty.
+ * A regularizer that applies an L1 or Lasso(least absolute shrinkage and selection operator)
+ * Regression, regularization penalty.
  *
  * <p>The L1 regularization penalty is computed as: <code>loss = l1 * reduceSum(abs(x))</code>
- *
- * @param <R> the data type for the weights
  */
-public class L1<R extends TNumber> extends L1L2<R> {
+public class L1 extends L1L2 {
 
   /**
    * Create a regularizer that applies an L1 regularization penalty of {@link
    * #DEFAULT_REGULARIZATION_PENALTY}
    *
    * @param tf the TensorFlow Ops
    */
-  public L1(Ops tf, Class<R> type) {
-    this(tf, DEFAULT_REGULARIZATION_PENALTY, type);
+  public L1(Ops tf) {
+    this(tf, DEFAULT_REGULARIZATION_PENALTY);
   }
 
   /**
@@ -44,7 +41,7 @@ public L1(Ops tf, Class<R> type) {
    * @param l1 the L1 regularization penalty
    * @throws IllegalArgumentException if the l1 regularization factor is NaN or is infinite.
    */
-  public L1(Ops tf, float l1, Class<R> type) {
-    super(tf, l1, null, type);
+  public L1(Ops tf, float l1) {
+    super(tf, l1, null);
   }
 }

tensorflow-framework/src/main/java/org/tensorflow/framework/regularizers/L1L2.java

@@ -32,22 +32,19 @@
  *
  * <p>The difference between this class and the {@link L1_L2} is use of the default regularization
  * penalty {@link #DEFAULT_REGULARIZATION_PENALTY}, whereas {@link L1L2} defaults to 0.
- *
- * @param <R> the data type for the weights
  */
-public class L1L2<R extends TNumber> extends Regularizer<R> {
+public class L1L2 extends Regularizer {
 
-  private final Float l1;
-  private final Float l2;
+  private final float l1;
+  private final float l2;
 
   /**
-   * Creates an L1L2 regularizer with no l1 or l2 penalty with default penal
+   * Creates an L1L2 regularizer with no l1 or l2 penalty with zero penalty
    *
    * @param tf the TensorFlow Ops
-   * @param type the data type for the weights
    */
-  public L1L2(Ops tf, Class<R> type) {
-    this(tf, null, null, type);
+  public L1L2(Ops tf) {
+    this(tf, null, null);
   }
 
   /**
@@ -56,12 +53,11 @@ public L1L2(Ops tf, Class<R> type) {
    * @param tf the TensorFlow Ops
    * @param l1 L1 regularization factor, if null it is set to 0.
    * @param l2 L2 regularization factor, if null it is set to 0.
-   * @param type the data type for the weights
    * @throws IllegalArgumentException if the l1 or l2 regularization factor is {@link Float#isNaN}
    *     of {@link Float#isInfinite}
    */
-  public L1L2(Ops tf, Float l1, Float l2, Class<R> type) {
-    super(tf, type);
+  public L1L2(Ops tf, Float l1, Float l2) {
+    super(tf);
     if (l1 != null) {
       if (l1.isNaN() || l1.isInfinite()) {
         throw new IllegalArgumentException(
@@ -86,25 +82,29 @@ public L1L2(Ops tf, Float l1, Float l2, Class<R> type) {
     }
   }
 
+  public static L1L2 l1_l2(Ops tf) {
+    return new L1L2(tf, DEFAULT_REGULARIZATION_PENALTY, DEFAULT_REGULARIZATION_PENALTY);
+  }
+
   /** {@inheritDoc} */
   @Override
-  public Operand<R> call(Operand<R> input) {
+  public <R extends TNumber> Operand<R> call(Operand<R> input) {
     Ops tf = getTF();
-    if (this.getL1() == null && this.getL2() == null) {
+    if (this.getL1() == 0f && this.getL2() == 0f) {
       return tf.dtypes.cast(tf.constant(0), input.type());
     }
     Operand<R> regularization = tf.dtypes.cast(tf.constant(0), input.type());
 
-    if (this.getL1() != null && this.getL1() != 0.f) {
+    if (this.getL1() != 0.f) {
       Operand<R> l1Op = tf.dtypes.cast(tf.constant(this.getL1()), input.type());
       Operand<R> abs = tf.math.abs(input);
       Operand<R> reduceSum = tf.reduceSum(abs, LossesHelper.allAxes(tf, input));
       regularization = tf.math.add(regularization, tf.math.mul(l1Op, reduceSum));
     }
 
-    if (this.getL2() != null && this.getL2() != 0.f) {
+    if (this.getL2() != 0.f) {
       Operand<R> l2Op = tf.dtypes.cast(tf.constant(this.getL2()), input.type());
-      Operand<R> sqr = tf.math.abs(input);
+      Operand<R> sqr = tf.math.square(input);
       Operand<R> reduceSum = tf.reduceSum(sqr, LossesHelper.allAxes(tf, input));
       regularization = tf.math.add(regularization, tf.math.mul(l2Op, reduceSum));
     }
@@ -117,7 +117,7 @@ public Operand<R> call(Operand<R> input) {
    *
    * @return the L1 regularization factor
    */
-  public Float getL1() {
+  public float getL1() {
     return l1;
   }
 
@@ -126,7 +126,7 @@ public Float getL1() {
    *
    * @return the L2 regularization factor
    */
-  public Float getL2() {
+  public float getL2() {
     return l2;
   }
 }

tensorflow-framework/src/main/java/org/tensorflow/framework/regularizers/L1_L2.java

@@ -15,7 +15,6 @@
 package org.tensorflow.framework.regularizers;
 
 import org.tensorflow.op.Ops;
-import org.tensorflow.types.family.TNumber;
 
 /**
  * A regularizer that applies both L1 and L2 regularization penalties.
@@ -30,33 +29,33 @@
  *
  * <p>The difference between this class and the {@link L1L2} is use of the default regularization
  * penalty {@link #DEFAULT_REGULARIZATION_PENALTY}, whereas {@link L1L2} defaults to 0.
- *
- * @param <R> the data type for the weights
  */
-public class L1_L2<R extends TNumber> extends L1L2<R> {
+public class L1_L2 extends L1L2 {
 
   /**
    * Creates a regularizer that applies an L1 and l2 regularization penalty of {@link
    * #DEFAULT_REGULARIZATION_PENALTY}
    *
    * @param tf the TensorFlow Ops
    */
-  public L1_L2(Ops tf, Class<R> type) {
-    this(tf, DEFAULT_REGULARIZATION_PENALTY, DEFAULT_REGULARIZATION_PENALTY, type);
+  public L1_L2(Ops tf) {
+    this(tf, DEFAULT_REGULARIZATION_PENALTY, DEFAULT_REGULARIZATION_PENALTY);
   }
 
   /**
    * Creates a regularizer that applies an L1 and l2 regularization penalty
    *
    * @param tf the TensorFlow Ops
-   * @param l1 the L1 regularization penalty
-   * @param l2 the L2 regularization penalty
+   * @param l1 the L1 regularization penalty. If null, then l1 will be set to {@link
+   *     #DEFAULT_REGULARIZATION_PENALTY}.
+   * @param l2 the L2 regularization penalty. If null, then l2 will be set to {@link
+   *     #DEFAULT_REGULARIZATION_PENALTY}.
    * @throws IllegalArgumentException if the l1 or l2 regularization factor is NaN or is infinite.
    */
-  public L1_L2(Ops tf, Float l1, Float l2, Class<R> type) {
-    super(tf,
-            l1 == null ? DEFAULT_REGULARIZATION_PENALTY : l1,
-            l2 == null ? DEFAULT_REGULARIZATION_PENALTY : l2,
-            type);
+  public L1_L2(Ops tf, Float l1, Float l2) {
+    super(
+        tf,
+        l1 == null ? DEFAULT_REGULARIZATION_PENALTY : l1,
+        l2 == null ? DEFAULT_REGULARIZATION_PENALTY : l2);
   }
 }

tensorflow-framework/src/main/java/org/tensorflow/framework/regularizers/L2.java

@@ -15,25 +15,22 @@
 package org.tensorflow.framework.regularizers;
 
 import org.tensorflow.op.Ops;
-import org.tensorflow.types.family.TNumber;
 
 /**
  * A regularizer that applies a L2 (Ridge Regression) regularization penalty.
  *
  * <p>The L2 regularization penalty is computed as: <code>loss = l2 * reduceSum(square(x))</code>
- *
- * @param <R> the data type for the operands and result
  */
-public class L2<R extends TNumber> extends L1L2<R> {
+public class L2 extends L1L2 {
 
   /**
    * Create a regularizer that applies an L2 regularization penalty of {@link
    * #DEFAULT_REGULARIZATION_PENALTY}
    *
    * @param tf the TensorFlow Ops
    */
-  public L2(Ops tf, Class<R> type) {
-    this(tf, DEFAULT_REGULARIZATION_PENALTY, type);
+  public L2(Ops tf) {
+    this(tf, DEFAULT_REGULARIZATION_PENALTY);
   }
 
   /**
@@ -43,7 +40,7 @@ public L2(Ops tf, Class<R> type) {
    * @param l2 the L2 regularization penalty
    * @throws IllegalArgumentException if the l2 regularization factor is NaN or is infinite.
    */
-  public L2(Ops tf, float l2, Class<R> type) {
-    super(tf, null, l2, type);
+  public L2(Ops tf, float l2) {
+    super(tf, null, l2);
   }
 }

tensorflow-framework/src/main/java/org/tensorflow/framework/regularizers/Regularizer.java

@@ -24,33 +24,31 @@
  *
  * <p>Regularizers allow you to apply penalties on layer parameters or layer activity during
  * optimization. These penalties are summed into the loss function that the network optimizes.
- *
- * @param <R> the data type of the operands and result
  */
-public abstract class Regularizer<R extends TNumber> {
+public abstract class Regularizer {
 
   public static final float DEFAULT_REGULARIZATION_PENALTY = 0.01f;
 
   private final Ops tf;
   private final String name;
-  protected Class<R> type;
 
   /**
-   * Creates a Regularizer
+   * Creates a Regularizer, using {@link Class#getSimpleName()} for the name
    *
    * @param tf the TensorFlow ops.
    */
-  protected Regularizer(Ops tf, Class<R> type) {
-    this(tf, null, type);
+  protected Regularizer(Ops tf) {
+    this(tf, null);
   }
   /**
    * Creates a Regularizer
    *
    * @param tf the TensorFlow ops.
+   * @param name the name of this regularizer, if null use {@link Class#getSimpleName()} for the
+   *     name.
    */
-  protected Regularizer(Ops tf, String name, Class<R> type) {
+  protected Regularizer(Ops tf, String name) {
     this.tf = tf;
-    this.type = type;
     this.name = name == null ? this.getClass().getSimpleName() : name;
   }
 
@@ -61,7 +59,7 @@ protected Regularizer(Ops tf, String name, Class<R> type) {
    * @return this Regularizer as a Loss
    */
   public Loss asLoss() {
-    return new RegularizerLoss<>(this.tf, this);
+    return new RegularizerLoss(this.tf, this);
   }
 
   /**
@@ -70,7 +68,7 @@ public Loss asLoss() {
    * @param input the weighted input
    * @return the result of computing the regularization penalty
    */
-  public abstract Operand<R> call(Operand<R> input);
+  public abstract <R extends TNumber> Operand<R> call(Operand<R> input);
 
   /**
    * Gets the TensorFlow Ops

tensorflow-framework/src/main/java/org/tensorflow/framework/regularizers/RegularizerLoss.java

@@ -19,27 +19,24 @@
 import org.tensorflow.op.Ops;
 import org.tensorflow.types.family.TNumber;
 
-import static org.tensorflow.framework.utils.CastHelper.cast;
-
 /**
  * A Regularizer call wrapped as a Loss instance
  *
  * <p>This class facilitates using a regularizer as a loss, only <code>sampleWeights</code> are
  * regularized.
- *
- * @param <R> the datatype for the weights type
  */
-class RegularizerLoss<R extends TNumber> extends Loss {
+class RegularizerLoss extends Loss {
+
+  private final Regularizer regularizer;
 
-  private final Regularizer<R> regularizer;
-  private final Class<R> type;
   /**
    * Creates a Loss using {@link Class#getSimpleName()} as the name and a Loss Reduction of {@link
    * Loss#REDUCTION_DEFAULT}
    *
    * @param tf the TensorFlow Ops
+   * @param regularizer the regularizer used to calculate the loss
    */
-  public RegularizerLoss(Ops tf, Regularizer<R> regularizer) {
+  public RegularizerLoss(Ops tf, Regularizer regularizer) {
     this(tf, null, regularizer);
   }
 
@@ -48,11 +45,11 @@ public RegularizerLoss(Ops tf, Regularizer<R> regularizer) {
    *
    * @param tf the TensorFlow Ops
    * @param name the name of this Loss, if null the name will be {@link Class#getSimpleName()}.
+   * @param regularizer the regularizer used to calculate the loss
    */
-  public RegularizerLoss(Ops tf, String name, Regularizer<R> regularizer) {
+  public RegularizerLoss(Ops tf, String name, Regularizer regularizer) {
     super(tf, name);
     this.regularizer = regularizer;
-    this.type = regularizer.type;
   }
 
   /** {@inheritDoc} */
@@ -62,7 +59,6 @@ public <T extends TNumber> Operand<T> call(
     if (sampleWeights == null) {
       throw new IllegalArgumentException("sampleWeights cannot be null");
     }
-    Operand<R> result = regularizer.call(cast(getTF(), sampleWeights, type));
-    return cast(tf, result, sampleWeights.type());
+    return regularizer.call(sampleWeights);
   }
 }