delete class L1_L2

modified Float to float for l1 and l2 parameters
Change ctor L1L2(Ops tf) to use DEFAULT_REGULARIZATION_PENALTY for l1/l2 parameters
Fix JavaDoc

Author: JimClarke5

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

@@ -42,6 +42,6 @@ public L1(Ops tf) {
    * @throws IllegalArgumentException if the l1 regularization factor is NaN or is infinite.
    */
   public L1(Ops tf, float l1) {
-    super(tf, l1, null);
+    super(tf, l1, 0f);
   }
 }

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

@@ -30,8 +30,6 @@
  *
  * <pre>loss = l2 * reduceSum(square(x))</pre>
  *
- * <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.
  */
 public class L1L2 extends Regularizer {
 
@@ -44,7 +42,7 @@ public class L1L2 extends Regularizer {
    * @param tf the TensorFlow Ops
    */
   public L1L2(Ops tf) {
-    this(tf, null, null);
+    this(tf, DEFAULT_REGULARIZATION_PENALTY, DEFAULT_REGULARIZATION_PENALTY);
   }
 
   /**
@@ -56,42 +54,25 @@ public L1L2(Ops tf) {
    * @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) {
+  public L1L2(Ops tf, float l1, float l2) {
     super(tf);
-    if (l1 != null) {
-      if (l1.isNaN() || l1.isInfinite()) {
-        throw new IllegalArgumentException(
-            String.format(
-                "L1 Value: %f is not a valid regularization penalty number, a positive/negative infinity or NaN is not a property value",
-                l1));
-      }
-      this.l1 = l1;
-    } else {
-      this.l1 = 0f;
+    if (Float.isNaN(l1) || Float.isInfinite(l1)) {
+      throw new IllegalArgumentException(
+          String.format(
+              "L1 Value: %f is not a valid regularization penalty number, a positive/negative infinity or NaN is not a property value",
+              l1));
     }
-    if (l2 != null) {
-      if (l2.isNaN() || l2.isInfinite()) {
-        throw new IllegalArgumentException(
-            String.format(
-                "L2 Value: %f is not a valid regularization penalty number, a positive/negative infinity or NaN is not a property value",
-                l2));
-      }
-      this.l2 = l2;
-    } else {
-      this.l2 = 0f;
+    this.l1 = l1;
+
+    if (Float.isNaN(l2) || Float.isInfinite(l2)) {
+      throw new IllegalArgumentException(
+          String.format(
+              "L2 Value: %f is not a valid regularization penalty number, a positive/negative infinity or NaN is not a property value",
+              l2));
     }
+    this.l2 = l2;
   }
 
-  /**
-   * Creates an L1L2 instance using {@link #DEFAULT_REGULARIZATION_PENALTY} for the l1 and l2
-   * values.
-   *
-   * @param tf the TensorFlow Ops
-   * @return a L1L2 instance using {@link #DEFAULT_REGULARIZATION_PENALTY} for the l1 and l2 values.
-   */
-  public static L1L2 create(Ops tf) {
-    return new L1L2(tf, DEFAULT_REGULARIZATION_PENALTY, DEFAULT_REGULARIZATION_PENALTY);
-  }
 
   /** {@inheritDoc} */
   @Override

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

@@ -41,6 +41,6 @@ public L2(Ops tf) {
    * @throws IllegalArgumentException if the l2 regularization factor is NaN or is infinite.
    */
   public L2(Ops tf, float l2) {
-    super(tf, null, l2);
+    super(tf, 0f, l2);
   }
 }

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

@@ -67,6 +67,7 @@ public Loss asLoss() {
    *
    * @param input the weighted input
    * @return the result of computing the regularization penalty
+   * @param <R> the data type of the input and result
    */
   public abstract <R extends TNumber> Operand<R> call(Operand<R> input);
 

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

@@ -21,17 +21,21 @@ public void testCreate() {
         assertEquals(0.2f, instance.getL1());
         assertEquals(0.3f, instance.getL2());
 
-        instance = new L1L2(tf, null, null);
+        instance = new L1L2(tf, 0, 0);
         assertEquals(0.f, instance.getL1());
         assertEquals(0.f, instance.getL2());
 
-        instance = new L1L2(tf, 0.5f, null);
+        instance = new L1L2(tf, 0.5f, 0);
         assertEquals(0.5f, instance.getL1());
         assertEquals(0.f, instance.getL2());
 
-        instance = new L1L2(tf, null, 0.5f);
+        instance = new L1L2(tf, 0, 0.5f);
         assertEquals(0.f, instance.getL1());
         assertEquals(0.5f, instance.getL2());
+
+        instance = new L1L2(tf);
+        assertEquals(Regularizer.DEFAULT_REGULARIZATION_PENALTY, instance.getL1());
+        assertEquals(Regularizer.DEFAULT_REGULARIZATION_PENALTY, instance.getL2());
       }
   }
 
@@ -42,16 +46,16 @@ public void testCallDefaultsConstant() {
         Ops tf = session.getTF();
         L1L2 instance = new L1L2(tf);
         Operand<TFloat32> result = instance.call(tf.constant(555f));
-        session.evaluate(0f, result);
+        session.evaluate(3085.8f, result);
       }
   }
 
   @Test
-  public void testCallL1L20() {
+  public void testCallL1L2_0() {
     for (TestSession.Mode tfMode : tfModes)
       try (TestSession session = TestSession.createTestSession(tfMode)) {
         Ops tf = session.getTF();
-        L1L2 instance = new L1L2(tf);
+        L1L2 instance = new L1L2(tf, 0, 0);
         Operand<TFloat32> weights =
             tf.constant(new float[][] {{1.0f, 0.9f, 0.8f}, {1.2f, 0.7f, 1.1f}});
         Operand<TFloat32> result = instance.call(weights);
@@ -90,11 +94,11 @@ public void testCallL1L2TFloat64() {
   }
 
   @Test
-  public void testCallL2Null() {
+  public void testCallL2_0() {
     for (TestSession.Mode tfMode : tfModes)
       try (TestSession session = TestSession.createTestSession(tfMode)) {
         Ops tf = session.getTF();
-        L1L2 instance = new L1L2(tf, 0.01f, null);
+        L1L2 instance = new L1L2(tf, 0.01f, 0);
         float[][] w = {{1.0f, 0.9f, 0.8f}, {1.2f, 0.7f, 1.1f}};
         Operand<TFloat32> weights = tf.constant(w);
         Operand<TFloat32> result = instance.call(weights);
@@ -104,11 +108,11 @@ public void testCallL2Null() {
   }
 
   @Test
-  public void testCallL1Null() {
+  public void testCallL1_0() {
     for (TestSession.Mode tfMode : tfModes)
       try (TestSession session = TestSession.createTestSession(tfMode)) {
         Ops tf = session.getTF();
-        L1L2 instance = new L1L2(tf, null, 0.02f);
+        L1L2 instance = new L1L2(tf, 0, 0.02f);
         double[][] w = {{1.0, 0.9, 0.8}, {1.2, 0.7, 1.1}};
         Operand<TFloat64> weights = tf.constant(w);
         Operand<TFloat64> result = instance.call(weights);

tensorflow-framework/src/test/java/org/tensorflow/framework/regularizers/L1L2Test.java

@@ -14,7 +14,7 @@ public void testCreate() {
     for (TestSession.Mode tfMode : tfModes)
       try (TestSession session = TestSession.createTestSession(tfMode)) {
         Ops tf = session.getTF();
-        L1L2 regularizer = new L1L2(tf, 0.01f, null);
+        L1L2 regularizer = new L1L2(tf, 0.01f, 0f);
         float[][] w = {{1.0f, 0.9f, 0.8f}, {1.2f, 0.7f, 1.1f}};
         Operand<TFloat32> weights = tf.constant(w);
         Operand<TFloat32> regularizerResult = regularizer.call(weights);