remove prints and comments

Author: Z80coder

neurallogic/hard_and.py

@@ -171,20 +171,9 @@ def __call__(self, x):
 
 
 def my_scope_put_variable(self, col: str, name: str, value: Any):
-    """Updates the value of the given variable if it is mutable, or an error otherwise.
-
-    Args:
-      col: the collection of the variable.
-      name: the name of the variable.
-      value: the new value of the given variable.
-    """
     self._check_valid()
     self._validate_trace_level()
-    #if not self.is_mutable_collection(col):
-    #    raise errors.ModifyScopeVariableError(col, name, self.path_text)
-    #variables = self._mutable_collection(col)
     variables = self._collection(col)
-    # Make sure reference sharing of child variable dictionaries isn't broken
 
     def put(target, key, val):
         if (key in target and isinstance(target[key], dict) and
@@ -198,25 +187,10 @@ def put(target, key, val):
 
 
 def my_put_variable(self, col: str, name: str, value: Any):
-    """Sets the value of a Variable.
-
-    Args:
-        col: the variable collection.
-        name: the name of the variable.
-        value: the new value of the variable.
-
-    Returns:
-
-    """
     if self.scope is None:
         raise ValueError("Can't access variables on unbound modules")
-    mutable_variables = self.scope.variables().unfreeze()
-    self.scope._variables = mutable_variables
-    #mutated_self = my_scope_put_variable(self.scope, col, name, value)
-    #self.scope.put_variable(col, name, value)
+    self.scope._variables = self.scope.variables().unfreeze()
     my_scope_put_variable(self.scope, col, name, value)
-    #immutable_scope = self.scope.variables.freeze()
-    #return immutable_scope
 
 
 class SymbolicAndLayer:
@@ -226,52 +200,18 @@ def __init__(self, layer_size):
 
     def __call__(self, x):
         symbolic_weights = self.hard_and_layer.get_variable("params", "weights")
-        print(f'symbolic_weights: {symbolic_weights} of type {type(symbolic_weights)}')
-        if isinstance(symbolic_weights, list) or (isinstance(symbolic_weights, numpy.ndarray) and symbolic_weights.dtype == numpy.object):
+        if isinstance(symbolic_weights, list) or (isinstance(symbolic_weights, numpy.ndarray) and symbolic_weights.dtype == object):
             symbolic_weights_n = symbolic_primitives.map_at_elements(symbolic_weights, lambda x: 0)
             symbolic_weights_n = numpy.asarray(symbolic_weights_n, dtype=numpy.float32)
             my_put_variable(self.hard_and_layer, "params", "weights", symbolic_weights_n)
-            print(f'converted to symbolic_weights_n: {symbolic_weights_n} of type {type(symbolic_weights_n)}')
-
-        #print(
-        #    f'symbolic_weights: {symbolic_weights} of type {type(symbolic_weights)}')
-        # Convert the symbolic inputs to numeric inputs so that we can generate a jaxpr
-        #numeric_weights = sym_gen.make_numeric(symbolic_weights)
-        #print(
-        #    f'numeric_weights: {numeric_weights} of type {type(numeric_weights)}')
-        #numeric_input = numpy.array(
-        #    sym_gen.make_numeric(x), dtype=numpy.float32)
-        #print(f'numeric_input: {numeric_input} of type {type(numeric_input)}')
-        # Overwrite the supplied weights with the temporary numeric weights
-        #my_put_variable(self.hard_and_layer, "params", "weights", symbolic_weights_n)
-        # Generate the jaxpr for this layer
-        #jaxpr = sym_gen.make_symbolic_jaxpr(self.hard_and_layer, numeric_input)
-        print(f'x: {x} of type {type(x)}')
-        if isinstance(x, numpy.ndarray):
-            print(f'x is a numpy array with dtype = {x.dtype}')
-        if isinstance(x, jax.numpy.ndarray):
-            print(f'x is a jax.numpy array with dtype = {x.dtype}')
-        #xn = sym_gen.make_numeric(x)
-        #print(f'converted to xn: {xn} of type {type(xn)}')
-        if isinstance(x, list) or (isinstance(x, numpy.ndarray) and x.dtype == numpy.object):
-            # x = numpy.zeros_like(list)
-            #x = numpy.asarray(x, dtype=numpy.float32)
+        if isinstance(x, list) or (isinstance(x, numpy.ndarray) and x.dtype == object):
             xn = symbolic_primitives.map_at_elements(x, lambda x: 0)
             xn = numpy.asarray(xn, dtype=numpy.float32)
         else:
             xn = x
-        print(f'converted to xn: {xn} of type {type(xn)}')
         jaxpr = sym_gen.make_symbolic_jaxpr(self.hard_and_layer, xn)
-        print(f'jaxpr consts: {jaxpr.consts} of type {type(jaxpr.consts)}')
-        print(f'jaxpr: {jaxpr}')
         # Swap out the numeric consts (that represent the weights) for the symbolic weights
         jaxpr.consts = [symbolic_weights]
-        #print(
-        #    f'symbolic jaxpr consts: {jaxpr.consts} of type {type(jaxpr.consts)}')
-        #symbolic_input = sym_gen.make_symbolic(x)
-        #print(
-        #    f'symbolic_input: {symbolic_input} of type {type(symbolic_input)}')
-        print(f'x: {x} of type {type(x)}')
         return sym_gen.symbolic_expression(jaxpr, x)
 
 

neurallogic/harden.py

@@ -71,7 +71,6 @@ def harden(x: dict):
 
 @dispatch
 def harden(*args):
-    print(f'harden: {args} of type {type(args)} with length {len(args)}')
     if len(args) == 1:
         return harden(args[0])
     return tuple([harden(arg) for arg in args])
@@ -83,8 +82,6 @@ def map_keys_nested(f, d: dict) -> dict:
 
 def hard_weights(weights):
     unfrozen_weights = weights.unfreeze()
-    print(f'Unfrozen weights: {unfrozen_weights} of type {type(unfrozen_weights)}')
     hard_weights = harden(unfrozen_weights)
-    print(f'Hard weights: {hard_weights} of type {type(hard_weights)}')
     return flax.core.FrozenDict(map_keys_nested(lambda str: str.replace("Soft", "Hard"), hard_weights))
 

neurallogic/sym_gen.py

@@ -83,8 +83,6 @@ def symbolic_write(var, val):
         safe_map(write, jaxpr.invars, args)
         safe_map(write, jaxpr.constvars, consts)
     safe_map(symbolic_write, jaxpr.invars, args)
-    print(f'jaxpr.constvars: {jaxpr.constvars} of type {type(jaxpr.constvars)}')
-    print(f'consts: {consts} of type {type(consts)}')
     safe_map(symbolic_write, jaxpr.constvars, consts)
 
     def eval_jaxpr_impl(jaxpr):
@@ -209,7 +207,6 @@ def make_symbolic(x: flax.core.FrozenDict):
     return flax.core.FrozenDict(make_symbolic(x))
 @dispatch
 def make_numeric(x: flax.core.FrozenDict):
-    #x = convert_jax_to_numpy_arrays(x.unfreeze())
     x = x.unfreeze()
     return flax.core.FrozenDict(make_numeric(x))
 
@@ -227,12 +224,6 @@ def eval_symbolic(symbolic_function, *args):
 
 def symbolic_expression(jaxpr, *args):
     if hasattr(jaxpr, 'literals'):
-        #symbolic_jaxpr_literals = safe_map(
-        #    lambda x: numpy.array(x, dtype=object), jaxpr.literals)
-        #symbolic_jaxpr_literals = make_symbolic(
-        #    symbolic_jaxpr_literals)
-        #sym_expr = eval_jaxpr(True, jaxpr.jaxpr,
-        #                      symbolic_jaxpr_literals, *args)
         sym_expr = eval_jaxpr(True, jaxpr.jaxpr,
                               jaxpr.literals, *args)
     else:

tests/test_hard_and.py

@@ -15,7 +15,6 @@ def check_consistency(soft: typing.Callable, hard: typing.Callable,  symbolic: t
 
     # Check that the hard function performs as expected
     hard_args = harden.harden(*args)
-    print(f'hard_args={hard_args} of type {type(hard_args)}')
     hard_expected = harden.harden(expected)
     assert numpy.allclose(hard(*hard_args), hard_expected)
 
@@ -106,7 +105,6 @@ def test_net(type, x):
 
     soft, hard, jaxpr, symbolic = neural_logic_net.net(test_net)
     weights = soft.init(random.PRNGKey(0), [0.0, 0.0])
-    print(f'Weights: {weights} of type {type(weights)}')
     hard_weights = harden.hard_weights(weights)
 
     test_data = [
@@ -144,7 +142,6 @@ def test_net(type, x):
 
         # Check that the symbolic function performs as expected
         symbolic_output = symbolic.apply(hard_weights, hard_input)
-        print(f'Symbolic output: {symbolic_output} of type {type(symbolic_output)}')
         assert numpy.allclose(symbolic_output, hard_expected)
 
 
@@ -209,7 +206,6 @@ def test_net(type, x):
     # Compute hard result
     hard_weights = harden.hard_weights(soft_weights)
     hard_input = harden.harden(soft_input)
-    print(f'hard_input: {hard_input} of type {type(hard_input)}')
     hard_result = hard.apply(hard_weights, numpy.array(hard_input))
     # Check that the hard result is the same as the soft result
     assert numpy.array_equal(harden.harden(soft_result), hard_result)
@@ -223,7 +219,6 @@ def test_net(type, x):
     symbolic_input = ['x1', 'x2']
     symbolic_output = symbolic.apply(hard_weights, symbolic_input)
     # Check the form of the symbolic expression
-    #print(f'Symbolic output: {symbolic_output} of type {type(symbolic_output)}')
     assert numpy.array_equal(symbolic_output, ['True and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or True) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or False) != 0.0 or False) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or False) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or True)',
  'True and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or False) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or False) != 0.0 or False) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or False) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or True)',
  'True and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or True) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or False) != 0.0 or True) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or False) and (True and (x1 != 0.0 or False) and (x2 != 0.0 or True) != 0.0 or True)',
@@ -233,7 +228,6 @@ def test_net(type, x):
     symbolic_weights = sym_gen.make_symbolic(hard_weights)
     symbolic_output = symbolic.apply(symbolic_weights, symbolic_input)
     # Check the form of the symbolic expression
-    #print(f'Symbolic output: {symbolic_output} of type {type(symbolic_output)}')
     assert numpy.array_equal(symbolic_output, ['True and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(False != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(True != 0.0)) != 0.0 or not(True != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(True != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(False != 0.0))',
  'True and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(True != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(True != 0.0)) != 0.0 or not(True != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(True != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(False != 0.0))',
  'True and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(False != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(True != 0.0)) != 0.0 or not(False != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(True != 0.0)) and (True and (x1 != 0.0 or not(True != 0.0)) and (x2 != 0.0 or not(False != 0.0)) != 0.0 or not(False != 0.0))',
@@ -242,11 +236,7 @@ def test_net(type, x):
     # Compute symbolic result with symbolic inputs and symbolic weights, but where the symbols can be evaluated
     symbolic_input = ['True', 'False']
     symbolic_output = symbolic.apply(symbolic_weights, symbolic_input)
-    #print(f'symbolic_output = {symbolic_output} of type {type(symbolic_output)}')
     symbolic_output = sym_gen.eval_symbolic_expression(symbolic_output)
-    #print(f'symbolic_output = {symbolic_output} of type {type(symbolic_output)}')
     # Check that the symbolic result is the same as the hard result
-    print(f'symbolic_output = {symbolic_output} of type {type(symbolic_output)}')
-    print(f'hard_result = {hard_result} of type {type(hard_result)}')
     assert numpy.array_equal(symbolic_output, hard_result)