Merge pull request #5452 from bscellier/import_numpy

theano/compile/builders.py

@@ -59,11 +59,11 @@ class OpFromGraph(gof.Op):
 
     .. code-block:: python
 
-        import numpy
+        import numpy as np
         import theano
         from theano import config, function, OpFromGraph, tensor
         x, y, z = tensor.scalars('xyz')
-        s = theano.shared(numpy.random.rand(2, 2).astype(config.floatX))
+        s = theano.shared(np.random.rand(2, 2).astype(config.floatX))
         e = x + y * z + s
         op = OpFromGraph([x, y, z], [e])
         # op behaves like a normal theano op

theano/compile/debugmode.py

@@ -14,7 +14,7 @@ import six.moves.copyreg as copyreg
 from itertools import chain, product as itertools_product
 from theano.compat import izip
 
-import numpy
+import numpy as np
 
 import theano
 from theano import gof, config
@@ -270,15 +270,15 @@ class BadOptimization(DebugModeError):
             print("  New Value: ", str(self.new_r_val), file=sio)
 
         try:
-            ov = numpy.asarray(self.old_r_val)
-            nv = numpy.asarray(self.new_r_val)
+            ov = np.asarray(self.old_r_val)
+            nv = np.asarray(self.new_r_val)
             ssio = StringIO()
-            abs_diff = numpy.absolute(nv - ov)
-            print("  Max Abs Diff: ", numpy.max(abs_diff), file=ssio)
-            print("  Mean Abs Diff: ", numpy.mean(abs_diff), file=ssio)
-            print("  Median Abs Diff: ", numpy.median(abs_diff), file=ssio)
-            print("  Std Abs Diff: ", numpy.std(abs_diff), file=ssio)
-            arg_max_val = numpy.argmax(abs_diff)
+            abs_diff = np.absolute(nv - ov)
+            print("  Max Abs Diff: ", np.max(abs_diff), file=ssio)
+            print("  Mean Abs Diff: ", np.mean(abs_diff), file=ssio)
+            print("  Median Abs Diff: ", np.median(abs_diff), file=ssio)
+            print("  Std Abs Diff: ", np.std(abs_diff), file=ssio)
+            arg_max_val = np.argmax(abs_diff)
             values_at_max = (nv.flatten()[arg_max_val],
                              ov.flatten()[arg_max_val])
             print("  Value at Max Diff: ", values_at_max, file=ssio)
@@ -286,13 +286,13 @@ class BadOptimization(DebugModeError):
             # N.B. the maximum(..., 1e-8) protects against div by 0 when
             #      nv == ov == 0
             reldiff = (abs_diff /
-                       numpy.maaximum(numpy.absolute(nv) + numpy.absolute(ov),
-                                      1e-8))
-            print("  Max Rel Diff: ", numpy.max(reldiff), file=ssio)
-            print("  Mean Rel Diff: ", numpy.mean(reldiff), file=ssio)
-            print("  Median Rel Diff: ", numpy.median(reldiff), file=ssio)
-            print("  Std Rel Diff: ", numpy.std(reldiff), file=ssio)
-            arg_max_val = numpy.argmax(reldiff)
+                       np.maximum(np.absolute(nv) + np.absolute(ov),
+                                  1e-8))
+            print("  Max Rel Diff: ", np.max(reldiff), file=ssio)
+            print("  Mean Rel Diff: ", np.mean(reldiff), file=ssio)
+            print("  Median Rel Diff: ", np.median(reldiff), file=ssio)
+            print("  Std Rel Diff: ", np.std(reldiff), file=ssio)
+            arg_max_val = np.argmax(reldiff)
             values_at_max = (nv.flatten()[arg_max_val],
                              ov.flatten()[arg_max_val])
             print("  Value at Max Diff: ", values_at_max, file=ssio)
@@ -342,8 +342,8 @@ class BadDestroyMap(DebugModeError):
         print("  repr (old val):", repr(self.old_val), file=sio)
         print("  repr (new val):", repr(self.new_val), file=sio)
         try:
-            npy_old_val = numpy.asarray(self.old_val)
-            npy_new_val = numpy.asarray(self.new_val)
+            npy_old_val = np.asarray(self.old_val)
+            npy_new_val = np.asarray(self.new_val)
             print("  value dtype (new <space> old):", npy_new_val.dtype,
                   npy_old_val.dtype, file=sio)
             print("  value shape (new <space> old):", npy_new_val.shape,
@@ -356,13 +356,13 @@ class BadDestroyMap(DebugModeError):
             print("  value min (new-old):", delta.min(), file=sio)
             print("  value max (new-old):", delta.max(), file=sio)
             print("  value argmin (new-old):",
-                  numpy.unravel_index(delta.argmin(), npy_new_val.shape),
+                  np.unravel_index(delta.argmin(), npy_new_val.shape),
                   file=sio)
             print("  value argmax (new-old):",
-                  numpy.unravel_index(delta.argmax(), npy_new_val.shape),
+                  np.unravel_index(delta.argmax(), npy_new_val.shape),
                   file=sio)
             print("  location of first 10 mismatches:",
-                  numpy.transpose(numpy.nonzero(delta))[:10], file=sio)
+                  np.transpose(np.nonzero(delta))[:10], file=sio)
             print("", file=sio)
         except Exception as e:
             print("(Numpy-hints failed with: %s)" % str(e), file=sio)
@@ -453,7 +453,7 @@ class InvalidValueError(DebugModeError):
             v_dtype = v.dtype
             v_min = v.min()
             v_max = v.max()
-            v_isfinite = numpy.all(numpy.isfinite(v))
+            v_isfinite = np.all(np.isfinite(v))
         except Exception:
             pass
         client_node = self.client_node
@@ -1025,7 +1025,7 @@ def _lessbroken_deepcopy(a):
     # this exists because copy.deepcopy on numpy arrays is broken
     # This logic is also in link.py
     from theano.gof.type import _cdata_type
-    if type(a) in (numpy.ndarray, numpy.memmap):
+    if type(a) in (np.ndarray, np.memmap):
         rval = a.copy()
     elif type(a) is _cdata_type:
         # This is not copyable (and should be used for constant data).
@@ -1034,7 +1034,7 @@ def _lessbroken_deepcopy(a):
         rval = copy.deepcopy(a)
 
     assert type(rval) == type(a), (type(rval), type(a))
-    if isinstance(rval, numpy.ndarray):
+    if isinstance(rval, np.ndarray):
         assert rval.dtype == a.dtype
     return rval
 
@@ -1241,7 +1241,7 @@ def _get_preallocated_maps(node, thunk, prealloc_modes, def_val,
             # There is no risk to overwrite inputs, since r does not work
             # inplace.
             if isinstance(r.type, (TensorType, CudaNdarrayType)):
-                reuse_outputs[r][...] = numpy.asarray(
+                reuse_outputs[r][...] = np.asarray(
                     def_val).astype(r.type.dtype)
 
         if reuse_outputs:
@@ -1259,7 +1259,7 @@ def _get_preallocated_maps(node, thunk, prealloc_modes, def_val,
                 new_buf = r.type.value_zeros(r_vals[r].shape)
                 # CudaNdarray don't have flags field
                 # assert new_buf.flags["C_CONTIGUOUS"]
-                new_buf[...] = numpy.asarray(def_val).astype(r.type.dtype)
+                new_buf[...] = np.asarray(def_val).astype(r.type.dtype)
 
                 c_cont_outputs[r] = new_buf
 
@@ -1273,7 +1273,7 @@ def _get_preallocated_maps(node, thunk, prealloc_modes, def_val,
         f_cont_outputs = {}
         for r in considered_outputs:
             if isinstance(r.type, (TensorType, CudaNdarrayType)):
-                new_buf = numpy.zeros(
+                new_buf = np.zeros(
                     shape=r_vals[r].shape,
                     dtype=r_vals[r].dtype,
                     order='F')
@@ -1331,7 +1331,7 @@ def _get_preallocated_maps(node, thunk, prealloc_modes, def_val,
                     else:
                         buf_shape.append(s * 2)
                 new_buf = r.type.value_zeros(buf_shape)
-                new_buf[...] = numpy.asarray(def_val).astype(r.type.dtype)
+                new_buf[...] = np.asarray(def_val).astype(r.type.dtype)
                 init_strided[r] = new_buf
 
         # The number of combinations is exponential in the number of
@@ -1377,7 +1377,7 @@ def _get_preallocated_maps(node, thunk, prealloc_modes, def_val,
                             r_buf = r_buf[tuple(strides)][tuple(shapes)]
                         assert r_buf.shape == r_vals[r].shape
 
-                        r_buf[...] = numpy.asarray(def_val).astype(r_buf.dtype)
+                        r_buf[...] = np.asarray(def_val).astype(r_buf.dtype)
                         strided[r] = r_buf
 
                 if strided:
@@ -1405,7 +1405,7 @@ def _get_preallocated_maps(node, thunk, prealloc_modes, def_val,
                                      for s, sd in zip(r_vals[r].shape,
                                                       r_shape_diff)]
                         new_buf = r.type.value_zeros(out_shape)
-                        new_buf[...] = numpy.asarray(
+                        new_buf[...] = np.asarray(
                             def_val).astype(r.type.dtype)
                         wrong_size[r] = new_buf
 
@@ -2261,7 +2261,7 @@ class _Linker(gof.link.LocalLinker):
                         # HACK TO LOOK LIKE A REAL DESTRUCTIVE ACTION
                         # TOOK PLACE
                         if ((type(dr_vals[r][0]) in
-                             (numpy.ndarray, numpy.memmap)) and
+                             (np.ndarray, np.memmap)) and
                             (dr_vals[r][0].dtype ==
                              storage_map[r][0].dtype) and
                             (dr_vals[r][0].shape ==

theano/compile/function.py

@@ -13,7 +13,7 @@ from six import string_types
 from theano.compile.io import In
 from theano.compile.function_module import orig_function
 from theano.compile.pfunc import pfunc
-from numpy import any
+import numpy as np
 import warnings
 from theano import compat
 
@@ -286,7 +286,7 @@ def function(inputs, outputs=None, mode=None, updates=None, givens=None,
                         "input.")
 
     # compute some features of the arguments:
-    uses_tuple = any([isinstance(i, (list, tuple)) for i in inputs])
+    uses_tuple = np.any([isinstance(i, (list, tuple)) for i in inputs])
     uses_updates = bool(updates)
     uses_givens = bool(givens)
 

theano/compile/function_module.py

@@ -12,7 +12,7 @@ import six.moves.cPickle as pickle
 from itertools import chain
 import time
 import warnings
-import numpy
+import numpy as np
 
 import theano
 from theano import config, gof
@@ -837,9 +837,9 @@ class Function(object):
                              in args_share_memory[j]],
                             [self.input_storage[k].storage[0] for k
                              in args_share_memory[j]])
-                        if numpy.any([(var.type is i_var.type and
-                                       var.type.may_share_memory(val, i_val))
-                                      for (var, val) in group_j]):
+                        if np.any([(var.type is i_var.type and
+                                  var.type.may_share_memory(val, i_val))
+                                  for (var, val) in group_j]):
 
                             is_aliased = True
                             args_share_memory[j].append(i)
@@ -1028,9 +1028,9 @@ def _pickle_Function(f):
         all_data = input_storage + inputs_data
         for i, d_i in enumerate(all_data):
             for j, d_j in enumerate(all_data):
-                if ((i < j) and isinstance(d_i, numpy.ndarray) and
-                        isinstance(d_j, numpy.ndarray)):
-                    if numpy.may_share_memory(d_i, d_j):
+                if ((i < j) and isinstance(d_i, np.ndarray) and
+                        isinstance(d_j, np.ndarray)):
+                    if np.may_share_memory(d_i, d_j):
                         if f.pickle_aliased_memory_strategy == 'warn':
                             _logger.warning('aliased relationship between '
                                             'Function arguments %s, %s '
@@ -1050,7 +1050,7 @@ def _constructor_Function(maker, input_storage, inputs_data):
     assert len(f.input_storage) == len(inputs_data)
     for container, x in zip(f.input_storage, inputs_data):
         assert (container.data is x) or \
-            (isinstance(x, numpy.ndarray) and (container.data == x).all()) or \
+            (isinstance(x, np.ndarray) and (container.data == x).all()) or \
             (container.data == x)
     return f
 

theano/compile/monitormode.py

 from __future__ import absolute_import, print_function, division
 # Note: this code was initially copied from the 'pyutools' package by its
 # original author, and re-licensed under Theano's license.
-import numpy
+import numpy as np
 
 import theano
 from theano.compile.mode import Mode
@@ -93,8 +93,8 @@ class MonitorMode(Mode):
 
 def detect_nan(i, node, fn):
     for output in fn.outputs:
-        if (not isinstance(output[0], numpy.random.RandomState) and
-                numpy.isnan(output[0]).any()):
+        if (not isinstance(output[0], np.random.RandomState) and
+                np.isnan(output[0]).any()):
             print('*** NaN detected ***')
             theano.printing.debugprint(node)
             print('Inputs : %s' % [input[0] for input in fn.inputs])

theano/compile/ops.py

@@ -17,7 +17,7 @@ from six import iteritems, integer_types
 from six.moves import xrange
 
 
-import numpy
+import numpy as np
 
 
 def register_view_op_c_code(type, code, version=()):
@@ -338,7 +338,7 @@ class Shape_i(gof.Op):
     def __init__(self, i):
         # As i will be used in the hash and that ndarray are not hashable,
         # we need to convert it to an int as it is hashable.
-        if isinstance(i, numpy.ndarray):
+        if isinstance(i, np.ndarray):
             assert i.dtype in theano.tensor.integer_dtypes
         assert i == int(i)
         i = int(i)
@@ -665,11 +665,11 @@ class Rebroadcast(gof.Op):
         items = sorted(axis)
         self.axis = OrderedDict(items)
         for axis, broad in iteritems(self.axis):
-            if not isinstance(axis, (numpy.integer, integer_types)):
+            if not isinstance(axis, (np.integer, integer_types)):
                 raise TypeError("Rebroadcast needs integer axes. "
                                 "Got {}".format(axis))
 
-            if not isinstance(broad, (numpy.bool_, bool)):
+            if not isinstance(broad, (np.bool_, bool)):
                 raise TypeError("Rebroadcast needs bool for new broadcast "
                                 "pattern. Got {}".format(broad))
 
@@ -835,8 +835,8 @@ class SpecifyShape(gof.Op):
         x, shape = inp
         out, = out_
         assert x.ndim == shape.size
-        assert numpy.all(x.shape == shape), ("got shape", x.shape,
-                                             "expected", shape)
+        assert np.all(x.shape == shape), ("got shape", x.shape,
+                                          "expected", shape)
         out[0] = x
 
     def infer_shape(self, node, shapes):

theano/compile/profiling.py

@@ -27,7 +27,7 @@ import sys
 import time
 from collections import defaultdict
 
-import numpy
+import numpy as np
 
 import theano
 from six import iteritems
@@ -477,7 +477,7 @@ class ProfileStats(object):
         hs += ['<#apply>']
         es += [' %4d  ']
 
-        upto_length = numpy.sum([len(x) for x in hs]) + len(hs)
+        upto_length = np.sum([len(x) for x in hs]) + len(hs)
         maxlen = max(self.line_width - upto_length, 0)
         hs += ['<Class name>']
         es += ['%s']
@@ -559,7 +559,7 @@ class ProfileStats(object):
         hs += ['<#apply>']
         es += ['  %4d  ']
 
-        upto_length = numpy.sum([len(x) for x in hs]) + len(hs)
+        upto_length = np.sum([len(x) for x in hs]) + len(hs)
         maxlen = max(self.line_width - upto_length, 0)
         hs += ['<Op name>']
         es += ['%s']
@@ -627,7 +627,7 @@ class ProfileStats(object):
         if self.variable_shape:
             hs += ['<Mflops>', '<Gflops/s>']
 
-        upto_length = numpy.sum([len(x) for x in hs]) + len(hs)
+        upto_length = np.sum([len(x) for x in hs]) + len(hs)
         maxlen = max(self.line_width - upto_length, 0)
         hs += ['<Apply name>']
         es += ['%s']
@@ -929,7 +929,7 @@ class ProfileStats(object):
             node_list = list(node_list)
             mem_count = 0
             max_mem_count = 0
-            mem_bound = numpy.inf
+            mem_bound = np.inf
             # This take only the inputs/outputs dependencies.
             dependencies = fgraph.profile.dependencies
             done_set = set([])

theano/compile/sharedvalue.py

@@ -9,7 +9,7 @@ import copy
 import logging
 
 # Third-party imports
-import numpy
+import numpy as np
 
 # Theano imports
 from theano.gof import Container, Variable, generic, utils
@@ -187,7 +187,7 @@ class SharedVariable(Variable):
         # implemented at all, but with a more explicit error message to help
         # Theano users figure out the root of the problem more easily.
         value = self.get_value(borrow=True)
-        if isinstance(value, numpy.ndarray):
+        if isinstance(value, np.ndarray):
             # Array probably had an unknown dtype.
             msg = ("a Numpy array with dtype: '%s'. This data type is not "
                    "currently recognized by Theano tensors: please cast "

theano/compile/tests/test_builders.py

 from __future__ import absolute_import, print_function, division
-import numpy
+import numpy as np
 
 from theano import config, shared
 
@@ -23,14 +23,14 @@ class T_OpFromGraph(unittest_tools.InferShapeTester):
         f = op(x, y, z) - op(y, z, x)
 
         fn = function([x, y, z], f)
-        xv = numpy.ones((2, 2), dtype=config.floatX)
-        yv = numpy.ones((2, 2), dtype=config.floatX) * 3
-        zv = numpy.ones((2, 2), dtype=config.floatX) * 5
+        xv = np.ones((2, 2), dtype=config.floatX)
+        yv = np.ones((2, 2), dtype=config.floatX) * 3
+        zv = np.ones((2, 2), dtype=config.floatX) * 5
         # print function, function.__module__
         # print fn.maker.fgraph.toposort()
         fn(xv, yv, zv)
-        assert numpy.all(8.0 == fn(xv, yv, zv))
-        assert numpy.all(8.0 == fn(xv, yv, zv))
+        assert np.all(8.0 == fn(xv, yv, zv))
+        assert np.all(8.0 == fn(xv, yv, zv))
 
     def test_size_changes(self):
         x, y, z = T.matrices('xyz')
@@ -38,15 +38,15 @@ class T_OpFromGraph(unittest_tools.InferShapeTester):
         op = OpFromGraph([x, y], [e])
         f = op(x, op(y, z))
         fn = function([x, y, z], f)
-        xv = numpy.ones((2, 3), dtype=config.floatX)
-        yv = numpy.ones((3, 4), dtype=config.floatX) * 3
-        zv = numpy.ones((4, 5), dtype=config.floatX) * 5
+        xv = np.ones((2, 3), dtype=config.floatX)
+        yv = np.ones((3, 4), dtype=config.floatX) * 3
+        zv = np.ones((4, 5), dtype=config.floatX) * 5
         res = fn(xv, yv, zv)
         assert res.shape == (2, 5)
-        assert numpy.all(180.0 == res)
+        assert np.all(180.0 == res)
         res = fn(xv, yv, zv)
         assert res.shape == (2, 5)
-        assert numpy.all(180.0 == res)
+        assert np.all(180.0 == res)
 
     def test_grad(self):
         x, y, z = T.matrices('xyz')
@@ -55,10 +55,10 @@ class T_OpFromGraph(unittest_tools.InferShapeTester):
         f = op(x, y, z)
         f = f - T.grad(T.sum(f), y)
         fn = function([x, y, z], f)
-        xv = numpy.ones((2, 2), dtype=config.floatX)
-        yv = numpy.ones((2, 2), dtype=config.floatX) * 3
-        zv = numpy.ones((2, 2), dtype=config.floatX) * 5
-        assert numpy.all(11.0 == fn(xv, yv, zv))
+        xv = np.ones((2, 2), dtype=config.floatX)
+        yv = np.ones((2, 2), dtype=config.floatX) * 3
+        zv = np.ones((2, 2), dtype=config.floatX) * 5
+        assert np.all(11.0 == fn(xv, yv, zv))
 
     def test_grad_grad(self):
         x, y, z = T.matrices('xyz')
@@ -68,47 +68,47 @@ class T_OpFromGraph(unittest_tools.InferShapeTester):
         f = f - T.grad(T.sum(f), y)
         f = f - T.grad(T.sum(f), y)
         fn = function([x, y, z], f)
-        xv = numpy.ones((2, 2), dtype=config.floatX)
-        yv = numpy.ones((2, 2), dtype=config.floatX) * 3
-        zv = numpy.ones((2, 2), dtype=config.floatX) * 5
-        assert numpy.allclose(6.0, fn(xv, yv, zv))
+        xv = np.ones((2, 2), dtype=config.floatX)
+        yv = np.ones((2, 2), dtype=config.floatX) * 3
+        zv = np.ones((2, 2), dtype=config.floatX) * 5
+        assert np.allclose(6.0, fn(xv, yv, zv))
 
     def test_shared(self):
         x, y, z = T.matrices('xyz')
-        s = shared(numpy.random.rand(2, 2).astype(config.floatX))
+        s = shared(np.random.rand(2, 2).astype(config.floatX))
         e = x + y * z + s
         op = OpFromGraph([x, y, z], [e])
         # (1+3*5=array of 16) - (3+1*5=array of 8)
         f = op(x, y, z) - op(y, z, x)
 
         fn = function([x, y, z], f)
-        xv = numpy.ones((2, 2), dtype=config.floatX)
-        yv = numpy.ones((2, 2), dtype=config.floatX) * 3
-        zv = numpy.ones((2, 2), dtype=config.floatX) * 5
+        xv = np.ones((2, 2), dtype=config.floatX)
+        yv = np.ones((2, 2), dtype=config.floatX) * 3
+        zv = np.ones((2, 2), dtype=config.floatX) * 5
         # print function, function.__module__
         # print fn.maker.fgraph.toposort()
-        assert numpy.allclose(8.0, fn(xv, yv, zv))
-        assert numpy.allclose(8.0, fn(xv, yv, zv))
+        assert np.allclose(8.0, fn(xv, yv, zv))
+        assert np.allclose(8.0, fn(xv, yv, zv))
 
     def test_shared_grad(self):
         x, y, z = T.matrices('xyz')
-        s = shared(numpy.random.rand(2, 2).astype(config.floatX))
+        s = shared(np.random.rand(2, 2).astype(config.floatX))
         e = x + y * z + s
         op = OpFromGraph([x, y, z], [e])
         f = op(x, y, z)
         f = f - T.grad(T.sum(f), y)
         fn = function([x, y, z], f)
-        xv = numpy.ones((2, 2), dtype=config.floatX)
-        yv = numpy.ones((2, 2), dtype=config.floatX) * 3
-        zv = numpy.ones((2, 2), dtype=config.floatX) * 5
-        assert numpy.allclose(11.0 + s.get_value(), fn(xv, yv, zv))
+        xv = np.ones((2, 2), dtype=config.floatX)
+        yv = np.ones((2, 2), dtype=config.floatX) * 3
+        zv = np.ones((2, 2), dtype=config.floatX) * 5
+        assert np.allclose(11.0 + s.get_value(), fn(xv, yv, zv))
 
         # grad again the shared variable
         f = op(x, y, z)
         f = f - T.grad(T.sum(f), s)
         fn = function([x, y, z], f)
-        assert numpy.allclose(15.0 + s.get_value(),
-                              fn(xv, yv, zv))
+        assert np.allclose(15.0 + s.get_value(),
+                           fn(xv, yv, zv))
 
     def test_connection_pattern(self):
         # Basic case
@@ -163,6 +163,6 @@ class T_OpFromGraph(unittest_tools.InferShapeTester):
         p = T.matrix('p')
         self._compile_and_check([q, p],
                                 op_graph(q, p),
-                                [numpy.ones([3, 4], dtype=config.floatX),
-                                 numpy.ones([3, 4], dtype=config.floatX)],
+                                [np.ones([3, 4], dtype=config.floatX),
+                                 np.ones([3, 4], dtype=config.floatX)],
                                 OpFromGraph)

theano/compile/tests/test_debugmode.py

@@ -2,7 +2,7 @@ from __future__ import absolute_import, print_function, division
 from nose.plugins.skip import SkipTest
 import unittest
 
-import numpy
+import numpy as np
 
 from theano import config
 from theano import gof
@@ -316,7 +316,7 @@ def test_just_c_code():
     x = theano.tensor.dvector()
     f = theano.function([x], wb2(x),
                         mode=debugmode.DebugMode(check_py_code=False))
-    assert numpy.all(f([1, 2]) == [2, 4])
+    assert np.all(f([1, 2]) == [2, 4])
 
 
 def test_baddestroymap():
@@ -349,7 +349,7 @@ def test_baddestroymap_c():
     f = theano.function([x], wb2i(x),
                         mode=debugmode.DebugMode(check_py_code=False))
     try:
-        assert numpy.all(f([1, 2]) == [2, 4])
+        assert np.all(f([1, 2]) == [2, 4])
         assert False  # failed to raise error
     except debugmode.BadDestroyMap:
         pass
@@ -445,8 +445,8 @@ class Test_ViewMap(unittest.TestCase):
 
         r0, r1 = f([1, 2, 3, 4], [5, 6, 7, 8])
 
-        assert numpy.all(r0 == [1, 2, 3, 4])
-        assert numpy.all(r1 == [2, 3, 4])
+        assert np.all(r0 == [1, 2, 3, 4])
+        assert np.all(r1 == [2, 3, 4])
 
     def test_aliased_outputs_ok_output(self):
         # here aliased outputs is ok because they are both outputs of the
@@ -470,8 +470,8 @@ class Test_ViewMap(unittest.TestCase):
 
         r0, r1 = f([1, 2, 3, 4], [5, 6, 7, 8])
 
-        assert numpy.all(r0 == [2, 4, 6, 8])
-        assert numpy.all(r1 == [4, 6, 8])
+        assert np.all(r0 == [2, 4, 6, 8])
+        assert np.all(r1 == [4, 6, 8])
 
     def test_aliased_outputs_ok_shadow(self):
         # here the alias between outputs is ok because one of them is not used
@@ -496,7 +496,7 @@ class Test_ViewMap(unittest.TestCase):
 
         r0 = f([1, 2, 3, 4], [5, 6, 7, 8])
 
-        assert numpy.all(r0 == [2, 4, 6, 8])
+        assert np.all(r0 == [2, 4, 6, 8])
 
     def test_aliased_outputs_bad(self):
         # here the alias between outputs is not ok because destroying one
@@ -555,31 +555,31 @@ class Test_check_isfinite(unittest.TestCase):
         g = theano.function([x], theano.tensor.log(x), mode='DEBUG_MODE')
 
         # this should work
-        f(numpy.log([3, 4, 5]).astype(config.floatX))
+        f(np.log([3, 4, 5]).astype(config.floatX))
 
         # if TensorType.filter_checks_isfinite were true, these would raise
         # ValueError
         # if not, DebugMode will check internally, and raise InvalidValueError
         # passing an invalid value as an input should trigger ValueError
         self.assertRaises(debugmode.InvalidValueError, f,
-                          numpy.log([3, -4, 5]).astype(config.floatX))
+                          np.log([3, -4, 5]).astype(config.floatX))
         self.assertRaises(debugmode.InvalidValueError, f,
-                          (numpy.asarray([0, 1.0, 0]) / 0).astype(config.floatX))
+                          (np.asarray([0, 1.0, 0]) / 0).astype(config.floatX))
         self.assertRaises(debugmode.InvalidValueError, f,
-                          (numpy.asarray([1.0, 1.0, 1.0]) / 0).astype(config.floatX))
+                          (np.asarray([1.0, 1.0, 1.0]) / 0).astype(config.floatX))
 
         # generating an invalid value internally should trigger
         # InvalidValueError
         self.assertRaises(debugmode.InvalidValueError, g,
-                          numpy.asarray([3, -4, 5], dtype=config.floatX))
+                          np.asarray([3, -4, 5], dtype=config.floatX))
 
         # this should disable the exception
         theano.tensor.TensorType.filter_checks_isfinite = False
         theano.compile.mode.predefined_modes[
             'DEBUG_MODE'].check_isfinite = False
         # insert several Inf
-        f(numpy.asarray(numpy.asarray([1.0, 1.0, 1.0]) / 0,
-                        dtype=config.floatX))
+        f(np.asarray(np.asarray([1.0, 1.0, 1.0]) / 0,
+                     dtype=config.floatX))
 
     def test_check_isfinite_disabled(self):
         x = theano.tensor.dvector()
@@ -587,10 +587,10 @@ class Test_check_isfinite(unittest.TestCase):
                             mode=debugmode.DebugMode(check_isfinite=False))
 
         # nan should go through
-        f(numpy.log([3, -4, 5]))
+        f(np.log([3, -4, 5]))
 
         # inf should go through
-        infs = numpy.asarray([1.0, 1., 1.]) / 0
+        infs = np.asarray([1.0, 1., 1.]) / 0
         # print infs
         f(infs)
         return
@@ -721,14 +721,14 @@ class VecAsRowAndCol(gof.Op):
 
 class Test_preallocated_output(unittest.TestCase):
     def setUp(self):
-        self.rng = numpy.random.RandomState(seed=utt.fetch_seed())
+        self.rng = np.random.RandomState(seed=utt.fetch_seed())
 
     def test_f_contiguous(self):
         a = theano.tensor.fmatrix('a')
         b = theano.tensor.fmatrix('b')
         z = BrokenCImplementationAdd()(a, b)
         # In this test, we do not want z to be an output of the graph.
-        out = theano.tensor.dot(z, numpy.eye(7))
+        out = theano.tensor.dot(z, np.eye(7))
 
         a_val = self.rng.randn(7, 7).astype('float32')
         b_val = self.rng.randn(7, 7).astype('float32')

theano/compile/tests/test_function.py

@@ -5,7 +5,7 @@ import shutil
 import tempfile
 import unittest
 
-import numpy
+import numpy as np
 
 import theano
 from theano.compile.io import In
@@ -27,7 +27,7 @@ def test_function_dump():
 
     fct2 = theano.function(**l)
     x = [1, 2, 3]
-    assert numpy.allclose(fct1(x), fct2(x))
+    assert np.allclose(fct1(x), fct2(x))
 
 
 class TestFunctionIn(unittest.TestCase):
@@ -40,14 +40,14 @@ class TestFunctionIn(unittest.TestCase):
 
         f = theano.function([In(a, strict=False)], out)
         # works, rand generates float64 by default
-        f(numpy.random.rand(8))
+        f(np.random.rand(8))
         # works, casting is allowed
-        f(numpy.array([1, 2, 3, 4], dtype='int32'))
+        f(np.array([1, 2, 3, 4], dtype='int32'))
 
         f = theano.function([In(a, strict=True)], out)
         try:
             # fails, f expects float64
-            f(numpy.array([1, 2, 3, 4], dtype='int32'))
+            f(np.array([1, 2, 3, 4], dtype='int32'))
         except TypeError:
             pass
 
@@ -70,17 +70,17 @@ class TestFunctionIn(unittest.TestCase):
 
         # using mutable=True will let f change the value in aval
         f = theano.function([In(a, mutable=True)], a_out, mode='FAST_RUN')
-        aval = numpy.random.rand(10)
+        aval = np.random.rand(10)
         aval2 = aval.copy()
-        assert numpy.all(f(aval) == (aval2 * 2))
-        assert not numpy.all(aval == aval2)
+        assert np.all(f(aval) == (aval2 * 2))
+        assert not np.all(aval == aval2)
 
         # using mutable=False should leave the input untouched
         f = theano.function([In(a, mutable=False)], a_out, mode='FAST_RUN')
-        aval = numpy.random.rand(10)
+        aval = np.random.rand(10)
         aval2 = aval.copy()
-        assert numpy.all(f(aval) == (aval2 * 2))
-        assert numpy.all(aval == aval2)
+        assert np.all(f(aval) == (aval2 * 2))
+        assert np.all(aval == aval2)
 
     def test_in_update(self):
         a = theano.tensor.dscalar('a')
@@ -115,7 +115,7 @@ class TestFunctionIn(unittest.TestCase):
         # changes occur at the same time and one doesn't overwrite the other.
         for i in range(5):
             f()
-            assert numpy.allclose(shared_var.get_value(), i % 2)
+            assert np.allclose(shared_var.get_value(), i % 2)
 
     def test_in_allow_downcast_int(self):
         a = theano.tensor.wvector('a')  # int16
@@ -128,16 +128,16 @@ class TestFunctionIn(unittest.TestCase):
 
         # Both values are in range. Since they're not ndarrays (but lists),
         # they will be converted, and their value checked.
-        assert numpy.all(f([3], [6], 1) == 10)
+        assert np.all(f([3], [6], 1) == 10)
 
         # Values are in range, but a dtype too large has explicitly been given
         # For performance reasons, no check of the data is explicitly performed
         # (It might be OK to change this in the future.)
-        self.assertRaises(TypeError, f, [3], numpy.array([6], dtype='int16'),
+        self.assertRaises(TypeError, f, [3], np.array([6], dtype='int16'),
                           1)
 
         # Value too big for a, silently ignored
-        assert numpy.all(f([2 ** 20], numpy.ones(1, dtype='int8'), 1) == 2)
+        assert np.all(f([2 ** 20], np.ones(1, dtype='int8'), 1) == 2)
 
         # Value too big for b, raises TypeError
         self.assertRaises(TypeError, f, [3], [312], 1)
@@ -156,17 +156,17 @@ class TestFunctionIn(unittest.TestCase):
                             (a + b + c))
 
         # If the values can be accurately represented, everything is OK
-        assert numpy.all(f(0, 0, 0) == 0)
+        assert np.all(f(0, 0, 0) == 0)
 
         # If allow_downcast is True, idem
-        assert numpy.allclose(f(0.1, 0, 0), 0.1)
+        assert np.allclose(f(0.1, 0, 0), 0.1)
 
         # If allow_downcast is False, nope
         self.assertRaises(TypeError, f, 0, 0.1, 0)
 
         # If allow_downcast is None, it should work iff floatX=float32
         if theano.config.floatX == 'float32':
-            assert numpy.allclose(f(0, 0, 0.1), 0.1)
+            assert np.allclose(f(0, 0, 0.1), 0.1)
         else:
             self.assertRaises(TypeError, f, 0, 0, 0.1)
 
@@ -182,10 +182,10 @@ class TestFunctionIn(unittest.TestCase):
 
         # If the values can be accurately represented, everything is OK
         z = [0]
-        assert numpy.all(f(z, z, z) == 0)
+        assert np.all(f(z, z, z) == 0)
 
         # If allow_downcast is True, idem
-        assert numpy.allclose(f([0.1], z, z), 0.1)
+        assert np.allclose(f([0.1], z, z), 0.1)
 
         # If allow_downcast is False, nope
         self.assertRaises(TypeError, f, z, [0.1], z)

theano/compile/tests/test_function_module.py

 from __future__ import absolute_import, print_function, division
 import copy
 import six.moves.cPickle as pickle
-import numpy
+import numpy as np
 import unittest
 
 
@@ -18,8 +18,6 @@ from theano import tensor
 from theano import tensor as T
 import theano
 
-import numpy as N
-
 
 def PatternOptimizer(p1, p2, ign=True):
     return gof.OpKeyOptimizer(gof.PatternSub(p1, p2), ignore_newtrees=ign)
@@ -281,7 +279,7 @@ class T_function(unittest.TestCase):
 
     def test_swap_SharedVariable(self):
         i = T.iscalar()
-        x_list = theano.shared(value=numpy.random.rand(10).astype(config.floatX))
+        x_list = theano.shared(value=np.random.rand(10).astype(config.floatX))
 
         x = T.scalar('x')
         # SharedVariable for tests, one of them has update
@@ -343,11 +341,11 @@ class T_function(unittest.TestCase):
         A special testcase for logistic_sgd.py in Deep Learning Tutorial
         This test assert that SharedVariable in different function have same storage
         """
-        train_x = theano.shared(value=numpy.random.rand(10, 10).astype(config.floatX))
-        test_x = theano.shared(value=numpy.random.rand(10, 10).astype(config.floatX))
+        train_x = theano.shared(value=np.random.rand(10, 10).astype(config.floatX))
+        test_x = theano.shared(value=np.random.rand(10, 10).astype(config.floatX))
 
-        train_y = theano.shared(value=numpy.random.rand(10, 1).astype(config.floatX))
-        test_y = theano.shared(value=numpy.random.rand(10, 1).astype(config.floatX))
+        train_y = theano.shared(value=np.random.rand(10, 1).astype(config.floatX))
+        test_y = theano.shared(value=np.random.rand(10, 1).astype(config.floatX))
 
         i = T.iscalar('index')
         x = T.vector('x')
@@ -500,42 +498,42 @@ class T_function(unittest.TestCase):
         when borrow=True is implemented.
         """
         a = T.dmatrix()
-        aval = numpy.random.rand(3, 3)
+        aval = np.random.rand(3, 3)
 
         # when borrow=False, test that a destroy map cannot alias output to input
         f = theano.function([In(a, borrow=False)], Out(a + 1, borrow=True))
-        assert numpy.all(f(aval) == aval + 1)
-        assert not numpy.may_share_memory(aval, f(aval))
+        assert np.all(f(aval) == aval + 1)
+        assert not np.may_share_memory(aval, f(aval))
 
         # when borrow=False, test that a viewmap cannot alias output to input
         f = theano.function([In(a, borrow=False)], Out(a[0, :], borrow=True))
-        assert numpy.all(f(aval) == aval[0, :])
-        assert not numpy.may_share_memory(aval, f(aval))
+        assert np.all(f(aval) == aval[0, :])
+        assert not np.may_share_memory(aval, f(aval))
 
     def test_borrow_output(self):
         a = T.dmatrix()
         f = function([a], Out(a, borrow=False))
-        o = N.ones((3, 3))
+        o = np.ones((3, 3))
         assert o is not f(o)  # function no longer permits aliasing outputs to inputs
 
         f = function([a], Out(a * 4, borrow=False))
-        o = N.ones((3, 3))
+        o = np.ones((3, 3))
         four = f(o)
-        assert numpy.all(four == 4)
+        assert np.all(four == 4)
         f(o + .1)  # should not clobber the memory used to store four
-        assert numpy.all(four == 4)
+        assert np.all(four == 4)
 
         f = function([a], Out(a * 4, borrow=True), mode=theano.Mode('c|py_nogc', 'fast_run'))
-        o = N.ones((3, 3))
+        o = np.ones((3, 3))
         four = f(o)
-        assert numpy.all(four == 4)
+        assert np.all(four == 4)
         f(o + .1)  # should clobber the memory used to store four
         if theano.config.cxx:
-            assert not numpy.all(four == 4)
+            assert not np.all(four == 4)
         else:
             # The Elemwise.perform method don't reuse memory
             # as some numpy version don't support that correctly.
-            assert numpy.all(four == 4)
+            assert np.all(four == 4)
 
     def test_disconnected_input(self):
         a = T.scalar('a')
@@ -767,7 +765,7 @@ class T_picklefunction(unittest.TestCase):
         assert f2.container[s].storage is f1.container[s].storage
 
         # now put in a function with non-scalar
-        v_value = numpy.asarray([2, 3, 4.], dtype=config.floatX)
+        v_value = np.asarray([2, 3, 4.], dtype=config.floatX)
         f3 = function([x, In(v, value=v_value)], x + v)
         list_of_things.append(f3)
 
@@ -814,13 +812,13 @@ class T_picklefunction(unittest.TestCase):
         assert nl[5](3) == ol[5](3)
         assert nl[4].value[nl[0]] == 6
 
-        assert numpy.all(nl[6][nl[2]] == numpy.asarray([2, 3., 4]))
+        assert np.all(nl[6][nl[2]] == np.asarray([2, 3., 4]))
 
     def test_broken_pickle_with_shared(self):
         saves = []
 
         def pers_save(obj):
-            if isinstance(obj, numpy.ndarray):
+            if isinstance(obj, np.ndarray):
                 saves.append(obj)
                 return len(saves) - 1
             else:
@@ -829,7 +827,7 @@ class T_picklefunction(unittest.TestCase):
         def pers_load(id):
             return saves[id]
 
-        b = numpy.random.rand(5, 4)
+        b = np.random.rand(5, 4)
 
         x = theano.tensor.matrix()
         y = theano.shared(b)

theano/compile/tests/test_misc.py

 from __future__ import absolute_import, print_function, division
 
-import numpy
+import numpy as np
 import unittest
 
 from theano.compile.pfunc import pfunc
@@ -20,8 +20,8 @@ class NNet(object):
         self.input = input
         self.target = target
         self.lr = shared(lr, 'learning_rate')
-        self.w1 = shared(numpy.zeros((n_hidden, n_input)), 'w1')
-        self.w2 = shared(numpy.zeros((n_output, n_hidden)), 'w2')
+        self.w1 = shared(np.zeros((n_hidden, n_input)), 'w1')
+        self.w2 = shared(np.zeros((n_output, n_hidden)), 'w2')
         # print self.lr.type
 
         self.hidden = sigmoid(tensor.dot(self.w1, self.input))
@@ -45,7 +45,7 @@ class NNet(object):
 class TestNnet(unittest.TestCase):
 
     def test_nnet(self):
-        rng = numpy.random.RandomState(1827)
+        rng = np.random.RandomState(1827)
         data = rng.rand(10, 4)
         nnet = NNet(n_input=3, n_hidden=10)
         for epoch in range(3):
@@ -60,4 +60,4 @@ class TestNnet(unittest.TestCase):
         self.assertTrue(abs(mean_cost - 0.20588975452) < 1e-6)
         # Just call functions to make sure they do not crash.
         nnet.compute_output(input)
-        nnet.output_from_hidden(numpy.ones(10))
+        nnet.output_from_hidden(np.ones(10))

theano/compile/tests/test_monitormode.py

 from __future__ import absolute_import, print_function, division
-import numpy
+import numpy as np
 
 import theano
 
@@ -12,7 +12,7 @@ def test_detect_nan():
 
     def detect_nan(i, node, fn):
         for output in fn.outputs:
-            if numpy.isnan(output[0]).any():
+            if np.isnan(output[0]).any():
                 print('*** NaN detected ***')
                 theano.printing.debugprint(node)
                 print('Inputs : %s' % [input[0] for input in fn.inputs])
@@ -36,7 +36,7 @@ def test_optimizer():
 
     def detect_nan(i, node, fn):
         for output in fn.outputs:
-            if numpy.isnan(output[0]).any():
+            if np.isnan(output[0]).any():
                 print('*** NaN detected ***')
                 theano.printing.debugprint(node)
                 print('Inputs : %s' % [input[0] for input in fn.inputs])
@@ -65,7 +65,7 @@ def test_not_inplace():
 
     def detect_nan(i, node, fn):
         for output in fn.outputs:
-            if numpy.isnan(output[0]).any():
+            if np.isnan(output[0]).any():
                 print('*** NaN detected ***')
                 theano.printing.debugprint(node)
                 print('Inputs : %s' % [input[0] for input in fn.inputs])

theano/compile/tests/test_nanguardmode.py

@@ -6,7 +6,7 @@ from __future__ import absolute_import, print_function, division
 import logging
 from nose.tools import assert_raises
 
-import numpy
+import numpy as np
 
 from theano.compile.nanguardmode import NanGuardMode
 import theano
@@ -18,20 +18,20 @@ def test_NanGuardMode():
     # intentionally. A working implementation should be able to capture all
     # the abnormalties.
     x = T.matrix()
-    w = theano.shared(numpy.random.randn(5, 7).astype(theano.config.floatX))
+    w = theano.shared(np.random.randn(5, 7).astype(theano.config.floatX))
     y = T.dot(x, w)
 
     fun = theano.function(
         [x], y,
         mode=NanGuardMode(nan_is_error=True, inf_is_error=True)
     )
-    a = numpy.random.randn(3, 5).astype(theano.config.floatX)
-    infa = numpy.tile(
-        (numpy.asarray(100.) ** 1000000).astype(theano.config.floatX), (3, 5))
-    nana = numpy.tile(
-        numpy.asarray(numpy.nan).astype(theano.config.floatX), (3, 5))
-    biga = numpy.tile(
-        numpy.asarray(1e20).astype(theano.config.floatX), (3, 5))
+    a = np.random.randn(3, 5).astype(theano.config.floatX)
+    infa = np.tile(
+        (np.asarray(100.) ** 1000000).astype(theano.config.floatX), (3, 5))
+    nana = np.tile(
+        np.asarray(np.nan).astype(theano.config.floatX), (3, 5))
+    biga = np.tile(
+        np.asarray(1e20).astype(theano.config.floatX), (3, 5))
 
     fun(a)  # normal values
 
@@ -46,14 +46,14 @@ def test_NanGuardMode():
         _logger.propagate = True
 
     # slices
-    a = numpy.random.randn(3, 4, 5).astype(theano.config.floatX)
-    infa = numpy.tile(
-        (numpy.asarray(100.) ** 1000000).astype(theano.config.floatX),
+    a = np.random.randn(3, 4, 5).astype(theano.config.floatX)
+    infa = np.tile(
+        (np.asarray(100.) ** 1000000).astype(theano.config.floatX),
         (3, 4, 5))
-    nana = numpy.tile(
-        numpy.asarray(numpy.nan).astype(theano.config.floatX), (3, 4, 5))
-    biga = numpy.tile(
-        numpy.asarray(1e20).astype(theano.config.floatX), (3, 4, 5))
+    nana = np.tile(
+        np.asarray(np.nan).astype(theano.config.floatX), (3, 4, 5))
+    biga = np.tile(
+        np.asarray(1e20).astype(theano.config.floatX), (3, 4, 5))
 
     x = T.tensor3()
     y = x[:, T.arange(2), T.arange(2)]

theano/compile/tests/test_ops.py

@@ -9,7 +9,6 @@ from theano.tests import unittest_tools as utt
 from theano import function
 import theano
 from theano.tensor import dmatrix, dvector
-from numpy import allclose
 from theano.compile import as_op
 import pickle
 
@@ -34,7 +33,7 @@ class OpDecoratorTests(utt.InferShapeTester):
         r = fn([[1.5, 5], [2, 2]])
         r0 = np.array([1.5, 7.5, 15., 30.])
 
-        assert allclose(r, r0), (r, r0)
+        assert np.allclose(r, r0), (r, r0)
 
     def test_2arg(self):
         x = dmatrix('x')
@@ -50,7 +49,7 @@ class OpDecoratorTests(utt.InferShapeTester):
         r = fn([[1.5, 5], [2, 2]], [1, 100, 2, 200])
         r0 = np.array([2.5, 107.5, 17., 230.])
 
-        assert allclose(r, r0), (r, r0)
+        assert np.allclose(r, r0), (r, r0)
 
     def test_infer_shape(self):
         x = dmatrix('x')

theano/compile/tests/test_pfunc.py

@@ -2,7 +2,7 @@ from __future__ import absolute_import, print_function, division
 import unittest
 
 from nose.plugins.skip import SkipTest
-import numpy
+import numpy as np
 
 import theano
 from theano.tensor import dmatrix, iscalar, lscalar, dmatrices
@@ -50,7 +50,7 @@ class Test_pfunc(unittest.TestCase):
     def test_shared(self):
 
         # CHECK: two functions (f1 and f2) can share w
-        w = shared(numpy.random.rand(2, 2), 'w')
+        w = shared(np.random.rand(2, 2), 'w')
         wval = w.get_value(borrow=False)
 
         x = dmatrix()
@@ -58,24 +58,24 @@ class Test_pfunc(unittest.TestCase):
         out2 = w * x
         f1 = pfunc([x], [out1])
         f2 = pfunc([x], [out2])
-        xval = numpy.random.rand(2, 2)
-        assert numpy.all(f1(xval) == xval + wval)
-        assert numpy.all(f2(xval) == xval * wval)
+        xval = np.random.rand(2, 2)
+        assert np.all(f1(xval) == xval + wval)
+        assert np.all(f2(xval) == xval * wval)
 
         # CHECK: updating a shared value
         f3 = pfunc([x], out1, updates=[(w, (w - 1))])
         # f3 changes the value of w
-        assert numpy.all(f3(xval) == xval + wval)
+        assert np.all(f3(xval) == xval + wval)
         # this same value is read by f1
-        assert numpy.all(f1(xval) == xval + (wval - 1))
+        assert np.all(f1(xval) == xval + (wval - 1))
 
         w.set_value(w.get_value(borrow=True) * 10, borrow=True)
         # this same value is read by f1
-        assert numpy.all(f1(xval) == xval + w.get_value(borrow=True))
+        assert np.all(f1(xval) == xval + w.get_value(borrow=True))
 
     def test_no_shared_as_input(self):
         """Test that shared variables cannot be used as function inputs."""
-        w_init = numpy.random.rand(2, 2)
+        w_init = np.random.rand(2, 2)
         w = shared(w_init.copy(), 'w')
         try:
             pfunc([w], theano.tensor.sum(w * w))
@@ -89,16 +89,16 @@ class Test_pfunc(unittest.TestCase):
         # Ensure it is possible to (implicitly) use a shared variable in a
         # function, as a 'state' that can be updated at will.
 
-        rng = numpy.random.RandomState(1827)
+        rng = np.random.RandomState(1827)
         w_init = rng.rand(5)
         w = shared(w_init.copy(), 'w')
         reg = theano.tensor.sum(w * w)
         f = pfunc([], reg)
 
-        assert f() == numpy.sum(w_init * w_init)
+        assert f() == np.sum(w_init * w_init)
         # Change the value of w and ensure the output changes accordingly.
         w.set_value(w.get_value(borrow=True) + 1.0, borrow=True)
-        assert f() == numpy.sum((w_init + 1) ** 2)
+        assert f() == np.sum((w_init + 1) ** 2)
 
     def test_default_scalar_container(self):
         # Similar in spirit to test_default_container, but updating a scalar
@@ -117,14 +117,14 @@ class Test_pfunc(unittest.TestCase):
 
         f = pfunc([In(a, strict=False)], [out])
         # works, rand generates float64 by default
-        f(numpy.random.rand(8))
+        f(np.random.rand(8))
         # works, casting is allowed
-        f(numpy.array([1, 2, 3, 4], dtype='int32'))
+        f(np.array([1, 2, 3, 4], dtype='int32'))
 
         f = pfunc([In(a, strict=True)], [out])
         try:
             # fails, f expects float64
-            f(numpy.array([1, 2, 3, 4], dtype='int32'))
+            f(np.array([1, 2, 3, 4], dtype='int32'))
         except TypeError:
             pass
 
@@ -134,20 +134,20 @@ class Test_pfunc(unittest.TestCase):
 
         # using mutable=True will let fip change the value in aval
         fip = pfunc([In(a, mutable=True)], [a_out], mode='FAST_RUN')
-        aval = numpy.random.rand(10)
+        aval = np.random.rand(10)
         aval2 = aval.copy()
-        assert numpy.all(fip(aval) == (aval2 * 2))
-        assert not numpy.all(aval == aval2)
+        assert np.all(fip(aval) == (aval2 * 2))
+        assert not np.all(aval == aval2)
 
         # using mutable=False should leave the input untouched
         f = pfunc([In(a, mutable=False)], [a_out], mode='FAST_RUN')
-        aval = numpy.random.rand(10)
+        aval = np.random.rand(10)
         aval2 = aval.copy()
-        assert numpy.all(f(aval) == (aval2 * 2))
-        assert numpy.all(aval == aval2)
+        assert np.all(f(aval) == (aval2 * 2))
+        assert np.all(aval == aval2)
 
     def test_shared_mutable(self):
-        bval = numpy.arange(5)
+        bval = np.arange(5)
         b = shared(bval)
         b_out = b * 2
 
@@ -158,26 +158,26 @@ class Test_pfunc(unittest.TestCase):
 
         # by default, shared are not mutable unless doing an explicit update
         f = pfunc([], [b_out], mode='FAST_RUN')
-        assert (f() == numpy.arange(5) * 2).all()
-        assert numpy.all(b.get_value(borrow=True) == numpy.arange(5))
+        assert (f() == np.arange(5) * 2).all()
+        assert np.all(b.get_value(borrow=True) == np.arange(5))
 
         # using updates, b is now a mutable parameter
         f = pfunc([], [b_out], updates=[(b, b_out)], mode='FAST_RUN')
-        assert (f() == (numpy.arange(5) * 2)).all()
+        assert (f() == (np.arange(5) * 2)).all()
         # because of the update
-        assert (b.get_value(borrow=True) == (numpy.arange(5) * 2)).all()
-        assert (bval == (numpy.arange(5) * 2)).all()  # because of mutable=True
+        assert (b.get_value(borrow=True) == (np.arange(5) * 2)).all()
+        assert (bval == (np.arange(5) * 2)).all()  # because of mutable=True
 
         # do not depend on updates being in-place though!
-        bval = numpy.arange(5)
+        bval = np.arange(5)
         b.set_value(bval, borrow=True)
         bval = data_of(b)
         f = pfunc([], [b_out], updates=[(b, (b_out + 3))], mode='FAST_RUN')
-        assert (f() == (numpy.arange(5) * 2)).all()
+        assert (f() == (np.arange(5) * 2)).all()
         # because of the update
-        assert (b.get_value(borrow=True) == ((numpy.arange(5) * 2) + 3)).all()
+        assert (b.get_value(borrow=True) == ((np.arange(5) * 2) + 3)).all()
         # bval got modified to something...
-        assert not (bval == numpy.arange(5)).all()
+        assert not (bval == np.arange(5)).all()
         # ... but not to b.value !
         assert not (bval == b.get_value(borrow=True)).all()
 
@@ -192,16 +192,16 @@ class Test_pfunc(unittest.TestCase):
 
         # Both values are in range. Since they're not ndarrays (but lists),
         # they will be converted, and their value checked.
-        assert numpy.all(f([3], [6], 1) == 10)
+        assert np.all(f([3], [6], 1) == 10)
 
         # Values are in range, but a dtype too large has explicitly been given
         # For performance reasons, no check of the data is explicitly performed
         # (It might be OK to change this in the future.)
         self.assertRaises(TypeError, f,
-                          [3], numpy.array([6], dtype='int16'), 1)
+                          [3], np.array([6], dtype='int16'), 1)
 
         # Value too big for a, silently ignored
-        assert numpy.all(f([2 ** 20], numpy.ones(1, dtype='int8'), 1) == 2)
+        assert np.all(f([2 ** 20], np.ones(1, dtype='int8'), 1) == 2)
 
         # Value too big for b, raises TypeError
         self.assertRaises(TypeError, f, [3], [312], 1)
@@ -220,17 +220,17 @@ class Test_pfunc(unittest.TestCase):
                   (a + b + c))
 
         # If the values can be accurately represented, everything is OK
-        assert numpy.all(f(0, 0, 0) == 0)
+        assert np.all(f(0, 0, 0) == 0)
 
         # If allow_downcast is True, idem
-        assert numpy.allclose(f(0.1, 0, 0), 0.1)
+        assert np.allclose(f(0.1, 0, 0), 0.1)
 
         # If allow_downcast is False, nope
         self.assertRaises(TypeError, f, 0, 0.1, 0)
 
         # If allow_downcast is None, it should work iff floatX=float32
         if config.floatX == 'float32':
-            assert numpy.allclose(f(0, 0, 0.1), 0.1)
+            assert np.allclose(f(0, 0, 0.1), 0.1)
         else:
             self.assertRaises(TypeError, f, 0, 0, 0.1)
 
@@ -246,10 +246,10 @@ class Test_pfunc(unittest.TestCase):
 
         # If the values can be accurately represented, everything is OK
         z = [0]
-        assert numpy.all(f(z, z, z) == 0)
+        assert np.all(f(z, z, z) == 0)
 
         # If allow_downcast is True, idem
-        assert numpy.allclose(f([0.1], z, z), 0.1)
+        assert np.allclose(f([0.1], z, z), 0.1)
 
         # If allow_downcast is False, nope
         self.assertRaises(TypeError, f, z, [0.1], z)
@@ -271,22 +271,22 @@ class Test_pfunc(unittest.TestCase):
         g = pfunc([a, b, c], (a + b + c), allow_input_downcast=False)
         # All values are in range. Since they're not ndarrays (but lists
         # or scalars), they will be converted, and their value checked.
-        assert numpy.all(g([3], [6], 0) == 9)
+        assert np.all(g([3], [6], 0) == 9)
 
         # Values are in range, but a dtype too large has explicitly been given
         # For performance reasons, no check of the data is explicitly performed
         # (It might be OK to change this in the future.)
         self.assertRaises(TypeError, g,
-                          [3], numpy.array([6], dtype='int16'), 0)
+                          [3], np.array([6], dtype='int16'), 0)
 
         # Value too big for b, raises TypeError
         self.assertRaises(TypeError, g, [3], [312], 0)
 
         h = pfunc([a, b, c], (a + b + c))  # Default: allow_input_downcast=None
         # Everything here should behave like with False
-        assert numpy.all(h([3], [6], 0) == 9)
+        assert np.all(h([3], [6], 0) == 9)
         self.assertRaises(TypeError, h,
-                          [3], numpy.array([6], dtype='int16'), 0)
+                          [3], np.array([6], dtype='int16'), 0)
         self.assertRaises(TypeError, h, [3], [312], 0)
 
     def test_allow_downcast_floatX(self):
@@ -298,21 +298,21 @@ class Test_pfunc(unittest.TestCase):
         h = pfunc([a, b], (a + b), allow_input_downcast=None)
 
         # If the values can be accurately represented, OK
-        assert numpy.all(f(0, [0]) == 0)
-        assert numpy.all(g(0, [0]) == 0)
-        assert numpy.all(h(0, [0]) == 0)
+        assert np.all(f(0, [0]) == 0)
+        assert np.all(g(0, [0]) == 0)
+        assert np.all(h(0, [0]) == 0)
 
         # For the vector: OK iff allow_input_downcast is True
-        assert numpy.allclose(f(0, [0.1]), 0.1)
+        assert np.allclose(f(0, [0.1]), 0.1)
         self.assertRaises(TypeError, g, 0, [0.1])
         self.assertRaises(TypeError, h, 0, [0.1])
 
         # For the scalar: OK if allow_input_downcast is True,
         # or None and floatX==float32
-        assert numpy.allclose(f(0.1, [0]), 0.1)
+        assert np.allclose(f(0.1, [0]), 0.1)
         self.assertRaises(TypeError, g, 0.1, [0])
         if config.floatX == 'float32':
-            assert numpy.allclose(h(0.1, [0]), 0.1)
+            assert np.allclose(h(0.1, [0]), 0.1)
         else:
             self.assertRaises(TypeError, h, 0.1, [0])
 
@@ -340,7 +340,7 @@ class Test_pfunc(unittest.TestCase):
 
     def test_update_err_broadcast(self):
         # Test that broadcastable dimensions raise error
-        data = numpy.random.rand(10, 10).astype('float32')
+        data = np.random.rand(10, 10).astype('float32')
         output_var = shared(name="output", value=data)
 
         # the update_var has type matrix, and the update expression
@@ -350,7 +350,7 @@ class Test_pfunc(unittest.TestCase):
 
     def test_duplicate_updates(self):
         x, y = dmatrices('x', 'y')
-        z = shared(numpy.ones((2, 3)))
+        z = shared(np.ones((2, 3)))
         self.assertRaises(ValueError, theano.function, [x, y], [z],
                           updates=[(z, (z + x + y)), (z, (z - x))])
 
@@ -362,29 +362,29 @@ class Test_pfunc(unittest.TestCase):
 
         y = tensor.ivector()
         f = pfunc([y], (y * x), givens={x: 6})
-        assert numpy.all(f([1, 1, 1]) == [6, 6, 6])
+        assert np.all(f([1, 1, 1]) == [6, 6, 6])
         assert x.get_value() == 0
 
         z = tensor.ivector()
         c = z * y
         f = pfunc([y], (c + 7),
                   givens={z: theano._asarray([4, 4, 4], dtype='int32')})
-        assert numpy.all(f([1, 1, 1]) == [11, 11, 11])
+        assert np.all(f([1, 1, 1]) == [11, 11, 11])
         assert x.get_value() == 0
 
     def test_clone0(self):
-        x = shared(numpy.asarray([4, 4, 4]))
-        y = shared(numpy.asarray([4, 4, 4]))
-        z = shared(numpy.asarray([2, 2, 2]))
+        x = shared(np.asarray([4, 4, 4]))
+        y = shared(np.asarray([4, 4, 4]))
+        z = shared(np.asarray([2, 2, 2]))
         up = pfunc([], [], updates={
             x: (x * 5),
             y: ((x * 5) + y),
             z: (((x * 5) + y) ** z)})
 
         up()
-        assert numpy.all(x.get_value() == 20)
-        assert numpy.all(y.get_value() == 24)
-        assert numpy.all(z.get_value() == (24 ** 2))
+        assert np.all(x.get_value() == 20)
+        assert np.all(y.get_value() == 24)
+        assert np.all(z.get_value() == (24 ** 2))
 
     def test_default_updates(self):
         x = shared(0)
@@ -625,7 +625,7 @@ class Test_pfunc(unittest.TestCase):
         # There was a bug in CVM, triggered when a shared variable
         # was its own update expression.
         a = shared(1., 'a')
-        b = shared(numpy.ones((2, 3)), 'b')
+        b = shared(np.ones((2, 3)), 'b')
 
         # The order of the variables is not determined, so we try
         # both shared variables.
@@ -650,7 +650,7 @@ class Test_pfunc(unittest.TestCase):
         # Like test_update_same, but the update expression is simplified until
         # it is found to be equal to the original variable
         a = shared(1., 'a')
-        b = shared(numpy.ones((2, 3)), 'b')
+        b = shared(np.ones((2, 3)), 'b')
 
         # See comment in test_update_same about why we try both
         # shared variables.
@@ -695,13 +695,13 @@ class Test_aliasing_rules(unittest.TestCase):
     def test_shared_constructor_copies(self):
         # shared constructor makes copy
         # (rule #2)
-        orig_a = numpy.zeros((2, 2))
+        orig_a = np.zeros((2, 2))
         A = self.shared(orig_a)
-        assert not numpy.may_share_memory(orig_a, data_of(A))
+        assert not np.may_share_memory(orig_a, data_of(A))
 
         # rule #2 reading back from theano-managed memory
-        assert not numpy.may_share_memory(A.get_value(borrow=False),
-                                          data_of(A))
+        assert not np.may_share_memory(A.get_value(borrow=False),
+                                       data_of(A))
 
     def test_sparse_input_aliasing_affecting_inplace_operations(self):
         ##
@@ -732,7 +732,7 @@ class Test_aliasing_rules(unittest.TestCase):
         # Test 1. If the same variable is given twice
 
         # Compute bogus values
-        m = sp.csc_matrix(numpy.asarray(
+        m = sp.csc_matrix(np.asarray(
             [[1, 0, 0, 0, 0],
              [0, 1, 0, 0, 0],
              [0, 0, 1, 0, 0],
@@ -742,7 +742,7 @@ class Test_aliasing_rules(unittest.TestCase):
         # Since we used inplace operation v and m may be corrupted
         # so we need to recreate them
 
-        m = sp.csc_matrix(numpy.asarray(
+        m = sp.csc_matrix(np.asarray(
             [[1, 0, 0, 0, 0],
              [0, 1, 0, 0, 0],
              [0, 0, 1, 0, 0],
@@ -751,7 +751,7 @@ class Test_aliasing_rules(unittest.TestCase):
         m_copy = m.copy()
         vals = f(m, m_copy)
 
-        assert numpy.allclose(vals.todense(), bogus_vals.todense())
+        assert np.allclose(vals.todense(), bogus_vals.todense())
 
     def test_input_aliasing_affecting_inplace_operations(self):
 
@@ -771,27 +771,27 @@ class Test_aliasing_rules(unittest.TestCase):
         # Test 1. If the same variable is given twice
 
         # Compute bogus values
-        v = numpy.asarray([1, 2, 3, 4, 5], dtype='float64')
-        m = numpy.asarray([[1, 0, 0, 0, 0],
-                           [0, 1, 0, 0, 0],
-                           [0, 0, 1, 0, 0],
-                           [0, 0, 0, 1, 0],
-                           [0, 0, 0, 0, 1]], dtype='float64')
+        v = np.asarray([1, 2, 3, 4, 5], dtype='float64')
+        m = np.asarray([[1, 0, 0, 0, 0],
+                        [0, 1, 0, 0, 0],
+                        [0, 0, 1, 0, 0],
+                        [0, 0, 0, 1, 0],
+                        [0, 0, 0, 0, 1]], dtype='float64')
         bogus_vals = f(v, v, m, m)
         # Since we used inplace operation v and m may be corrupted
         # so we need to recreate them
 
-        v = numpy.asarray([1, 2, 3, 4, 5], dtype='float64')
-        m = numpy.asarray([[1, 0, 0, 0, 0],
-                           [0, 1, 0, 0, 0],
-                           [0, 0, 1, 0, 0],
-                           [0, 0, 0, 1, 0],
-                           [0, 0, 0, 0, 1]], dtype='float64')
+        v = np.asarray([1, 2, 3, 4, 5], dtype='float64')
+        m = np.asarray([[1, 0, 0, 0, 0],
+                        [0, 1, 0, 0, 0],
+                        [0, 0, 1, 0, 0],
+                        [0, 0, 0, 1, 0],
+                        [0, 0, 0, 0, 1]], dtype='float64')
         m_copy = m.copy()
         v_copy = v.copy()
         vals = f(v, v_copy, m, m_copy)
 
-        assert numpy.allclose(vals, bogus_vals)
+        assert np.allclose(vals, bogus_vals)
 
     def test_partial_input_aliasing_affecting_inplace_operations(self):
 
@@ -822,102 +822,102 @@ class Test_aliasing_rules(unittest.TestCase):
              theano.dot((z * 4), m3)))
 
         # Compute bogus values
-        v = numpy.asarray([1, 2, 3, 4, 5], dtype='float64')
-        m = numpy.asarray([[1, 0],
-                           [0, 1]], dtype='float64')
+        v = np.asarray([1, 2, 3, 4, 5], dtype='float64')
+        m = np.asarray([[1, 0],
+                        [0, 1]], dtype='float64')
         bogus_vals = f(v[:2], v[1:3], v[2:4], m, m, m)
         # Since we used inplace operation v and m may be corrupted
         # so we need to recreate them
 
-        v = numpy.asarray([1, 2, 3, 4, 5], dtype='float64')
-        m = numpy.asarray([[1, 0],
-                           [0, 1]], dtype='float64')
+        v = np.asarray([1, 2, 3, 4, 5], dtype='float64')
+        m = np.asarray([[1, 0],
+                        [0, 1]], dtype='float64')
         m_copy1 = m.copy()
         v_copy1 = v.copy()
         m_copy2 = m.copy()
         v_copy2 = v.copy()
         vals = f(v[:2], v_copy1[1:3], v_copy2[2:4], m, m_copy1, m_copy2)
 
-        assert numpy.allclose(vals, bogus_vals)
+        assert np.allclose(vals, bogus_vals)
 
     def test_potential_output_aliasing_induced_by_updates(self):
 
-        A = self.shared(numpy.zeros((2, 2)))
-        B = self.shared(numpy.zeros((2, 2)))
-        C = numpy.zeros((2, 2))
+        A = self.shared(np.zeros((2, 2)))
+        B = self.shared(np.zeros((2, 2)))
+        C = np.zeros((2, 2))
         D = tensor.dmatrix()
         DD = D + 5
 
         f = pfunc([D], [], updates=[(A, D), (B, D)])
         f(C)
 
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
         f = pfunc([D], [], updates=[(A, D[:]), (B, D)])
         f(C)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
         f = pfunc([D], [], updates=[(A, (D + 5)), (B, D[:])])
         f(C)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
 
         f = pfunc([D], [], updates=[(A, (D + 5)), (B, D)])
         f(C)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
 
         f = pfunc([D], DD, updates=[(A, DD[:1]), (B, DD)])
         R = f(C)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
-        assert not numpy.may_share_memory(R, data_of(B))
-        assert not numpy.may_share_memory(R, data_of(A))
+        assert not np.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(R, data_of(B))
+        assert not np.may_share_memory(R, data_of(A))
 
         f = pfunc([D], DD, updates=[(A, DD[:1]), (B, (DD[:1] * 2))])
         R = f(C)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
-        assert not numpy.may_share_memory(R, data_of(B))
-        assert not numpy.may_share_memory(R, data_of(A))
+        assert not np.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(R, data_of(B))
+        assert not np.may_share_memory(R, data_of(A))
 
         f = pfunc([D], (DD * 4),
                   updates=[(A, (DD[:1] * 3)), (B, (DD[:1] * 2))])
         R = f(C)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
-        assert not numpy.may_share_memory(R, data_of(B))
-        assert not numpy.may_share_memory(R, data_of(A))
+        assert not np.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(R, data_of(B))
+        assert not np.may_share_memory(R, data_of(A))
 
         f = pfunc([D], (DD * 4),
                   updates=[(A, (DD[:1] * 3)), (B, (DD[:1] * 3))])
         R = f(C)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
-        assert not numpy.may_share_memory(R, data_of(B))
-        assert not numpy.may_share_memory(R, data_of(A))
+        assert not np.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(R, data_of(B))
+        assert not np.may_share_memory(R, data_of(A))
 
     def test_no_aliasing_0(self):
         # B is a shared variable, A is updated with B's contents
         # we need A to be copied to avoid aliasing
-        A = self.shared(numpy.zeros((2, 2)) + .5)
-        B = self.shared(numpy.zeros((2, 2)) - .5)
+        A = self.shared(np.zeros((2, 2)) + .5)
+        B = self.shared(np.zeros((2, 2)) - .5)
         f = pfunc([], [], updates=[(A, B)])
         f()
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
 
     def test_no_aliasing_1(self):
         # B is a shared variable, A is updated with B's contents
         # since B is being updated as well, we don't need to copy anything
         # to avoid aliasing shared variables.
-        A = self.shared(numpy.zeros((2, 2)) + .5)
-        B = self.shared(numpy.zeros((2, 2)) - .5)
+        A = self.shared(np.zeros((2, 2)) + .5)
+        B = self.shared(np.zeros((2, 2)) - .5)
         C = tensor.dmatrix()
         f = pfunc([C], [], updates=[(A, B), (B, C)])
-        z = numpy.zeros((2, 2))
+        z = np.zeros((2, 2))
         f(z)
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
         # Theano tries to maintain its own memory space.
-        assert not numpy.may_share_memory(z, data_of(B))
-        assert numpy.all(data_of(B) == z)
+        assert not np.may_share_memory(z, data_of(B))
+        assert np.all(data_of(B) == z)
 
     def test_no_aliasing_2(self):
         # B and A take one another's values
         # no copying is necessary since each one is updated.
-        orig_a = numpy.zeros((2, 2)) + .5
-        orig_b = numpy.zeros((2, 2)) - .5
+        orig_a = np.zeros((2, 2)) + .5
+        orig_b = np.zeros((2, 2)) - .5
         A = self.shared(orig_a)
         B = self.shared(orig_b)
 
@@ -927,15 +927,15 @@ class Test_aliasing_rules(unittest.TestCase):
         f = pfunc([], [], updates=[(A, B), (B, A)])
         f()
         # correctness
-        assert numpy.all(data_of(A) == -.5)
-        assert numpy.all(data_of(B) == +.5)
+        assert np.all(data_of(A) == -.5)
+        assert np.all(data_of(B) == +.5)
 
         # shared vars may not be aliased
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
 
         # theano should have been smart enough to not make copies
-        assert numpy.may_share_memory(data_of(A), data_of_b)
-        assert numpy.may_share_memory(data_of(B), data_of_a)
+        assert np.may_share_memory(data_of(A), data_of_b)
+        assert np.may_share_memory(data_of(B), data_of_a)
 
     def test_no_aliasing_2b(self):
         # B and A take one another's values
@@ -943,8 +943,8 @@ class Test_aliasing_rules(unittest.TestCase):
         # The twist one `test_no_aliasing_2` is that each shared var is updated
         # with a view of the other one.
 
-        orig_a = numpy.zeros((2, 2)) + .5
-        orig_b = numpy.zeros((2, 2)) - .5
+        orig_a = np.zeros((2, 2)) + .5
+        orig_b = np.zeros((2, 2)) - .5
         A = self.shared(orig_a)
         B = self.shared(orig_b)
 
@@ -955,30 +955,30 @@ class Test_aliasing_rules(unittest.TestCase):
         # theano.printing.debugprint(f)
         f()
         # correctness (doesn't actually test the view...)
-        assert numpy.all(data_of(A) == -.5)
-        assert numpy.all(data_of(B) == +.5)
+        assert np.all(data_of(A) == -.5)
+        assert np.all(data_of(B) == +.5)
 
         # shared vars may not be aliased
-        assert not numpy.may_share_memory(data_of(A), data_of(B))
+        assert not np.may_share_memory(data_of(A), data_of(B))
 
         # theano should have been smart enough to not make copies
         if theano.config.mode not in [
                 'DebugMode', 'DEBUG_MODE', 'FAST_COMPILE']:
             # We don't ask DebugMode and FAST_COMPILE not to make copy.
             # We have the right to do so.
-            assert numpy.all(data_of(A) < 5)
+            assert np.all(data_of(A) < 5)
             data_of_b += 10
-            assert numpy.all(data_of(A) > 5)
+            assert np.all(data_of(A) > 5)
             data_of_b -= 10
 
-            assert numpy.all(data_of(B) < 5)
+            assert np.all(data_of(B) < 5)
             data_of_a += 10
-            assert numpy.all(data_of(B) > 5)
+            assert np.all(data_of(B) > 5)
             data_of_a -= 10
 
             # N.B. may_share_memory is what we mean, but does it work?
-            assert numpy.may_share_memory(data_of(A), data_of_b)
-            assert numpy.may_share_memory(data_of(B), data_of_a)
+            assert np.may_share_memory(data_of(A), data_of_b)
+            assert np.may_share_memory(data_of(B), data_of_a)
 
             # N.B. This pattern could form a memory leak - each shared
             # variable always points to a view, and that view gets
@@ -995,9 +995,9 @@ class Test_rebuild_strict(unittest.TestCase):
         x, y = tensor.ivectors('x', 'y')
         z = x * y
         f = theano.function([w, y], z, givens=[(x, w)], rebuild_strict=False)
-        z_val = f(numpy.ones((3, 5), dtype='int32'), numpy.arange(5, dtype='int32'))
+        z_val = f(np.ones((3, 5), dtype='int32'), np.arange(5, dtype='int32'))
         assert z_val.ndim == 2
-        assert numpy.all(z_val == numpy.ones((3, 5)) * numpy.arange(5))
+        assert np.all(z_val == np.ones((3, 5)) * np.arange(5))
 
 
 if __name__ == '__main__':

theano/compile/tests/test_profiling.py

@@ -6,7 +6,7 @@ from __future__ import absolute_import, print_function, division
 
 import unittest
 
-import numpy
+import numpy as np
 
 import theano
 from six.moves import StringIO
@@ -45,7 +45,7 @@ class Test_profiling(unittest.TestCase):
             f = theano.function(x, z, profile=p, name="test_profiling",
                                 mode=m)
 
-            inp = [numpy.arange(1024, dtype='float32') + 1 for i in range(len(x))]
+            inp = [np.arange(1024, dtype='float32') + 1 for i in range(len(x))]
             f(*inp)
 
             buf = StringIO()

theano/compile/tests/test_shared.py

 from __future__ import absolute_import, print_function, division
-import numpy
+import numpy as np
 import unittest
 
 import theano
@@ -18,14 +18,14 @@ class Test_SharedVariable(unittest.TestCase):
         else:
             assert shared(7).type == theano.tensor.lscalar, shared(7).type
         assert shared(7.0).type == theano.tensor.dscalar
-        assert shared(numpy.float32(7)).type == theano.tensor.fscalar
+        assert shared(np.float32(7)).type == theano.tensor.fscalar
 
         # test tensor constructor
-        b = shared(numpy.zeros((5, 5), dtype='int32'))
+        b = shared(np.zeros((5, 5), dtype='int32'))
         assert b.type == TensorType('int32', broadcastable=[False, False])
-        b = shared(numpy.random.rand(4, 5))
+        b = shared(np.random.rand(4, 5))
         assert b.type == TensorType('float64', broadcastable=[False, False])
-        b = shared(numpy.random.rand(5, 1, 2))
+        b = shared(np.random.rand(5, 1, 2))
         assert b.type == TensorType('float64', broadcastable=[False, False, False])
 
         assert shared([]).type == generic
@@ -52,7 +52,7 @@ class Test_SharedVariable(unittest.TestCase):
         SharedVariable(
             name='u',
             type=Tensor(broadcastable=[False], dtype='float64'),
-            value=numpy.asarray([1., 2.]),
+            value=np.asarray([1., 2.]),
             strict=False)
 
         # here the value is castable, and we're not strict about it,
@@ -90,14 +90,14 @@ class Test_SharedVariable(unittest.TestCase):
         u = SharedVariable(
             name='u',
             type=Tensor(broadcastable=[False], dtype='float64'),
-            value=numpy.asarray([1., 2.]),
+            value=np.asarray([1., 2.]),
             strict=False)
 
         # check that assignments to value are cast properly
         u.set_value([3, 4])
-        assert type(u.get_value()) is numpy.ndarray
+        assert type(u.get_value()) is np.ndarray
         assert str(u.get_value(borrow=True).dtype) == 'float64'
-        assert numpy.all(u.get_value() == [3, 4])
+        assert np.all(u.get_value() == [3, 4])
 
         # check that assignments of nonsense fail
         try:
@@ -115,31 +115,31 @@ class Test_SharedVariable(unittest.TestCase):
         def f(var, val):
             var.set_value(val)
 
-        b = shared(numpy.int64(7), strict=True)
+        b = shared(np.int64(7), strict=True)
         assert b.type == theano.tensor.lscalar
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.int32(7), strict=True)
+        b = shared(np.int32(7), strict=True)
         assert b.type == theano.tensor.iscalar
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.int16(7), strict=True)
+        b = shared(np.int16(7), strict=True)
         assert b.type == theano.tensor.wscalar
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.int8(7), strict=True)
+        b = shared(np.int8(7), strict=True)
         assert b.type == theano.tensor.bscalar
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.float64(7.234), strict=True)
+        b = shared(np.float64(7.234), strict=True)
         assert b.type == theano.tensor.dscalar
         self.assertRaises(TypeError, f, b, 8)
 
-        b = shared(numpy.float32(7.234), strict=True)
+        b = shared(np.float32(7.234), strict=True)
         assert b.type == theano.tensor.fscalar
         self.assertRaises(TypeError, f, b, 8)
 
-        b = shared(numpy.float(7.234), strict=True)
+        b = shared(np.float(7.234), strict=True)
         assert b.type == theano.tensor.dscalar
         self.assertRaises(TypeError, f, b, 8)
 
@@ -147,39 +147,39 @@ class Test_SharedVariable(unittest.TestCase):
         assert b.type == theano.tensor.dscalar
         self.assertRaises(TypeError, f, b, 8)
 
-        b = shared(numpy.zeros((5, 5), dtype='float32'))
-        self.assertRaises(TypeError, f, b, numpy.random.rand(5, 5))
+        b = shared(np.zeros((5, 5), dtype='float32'))
+        self.assertRaises(TypeError, f, b, np.random.rand(5, 5))
 
     def test_tensor_strict(self):
         def f(var, val):
             var.set_value(val)
 
-        b = shared(numpy.int64([7]), strict=True)
+        b = shared(np.int64([7]), strict=True)
         assert b.type == theano.tensor.lvector
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.int32([7]), strict=True)
+        b = shared(np.int32([7]), strict=True)
         assert b.type == theano.tensor.ivector
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.int16([7]), strict=True)
+        b = shared(np.int16([7]), strict=True)
         assert b.type == theano.tensor.wvector
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.int8([7]), strict=True)
+        b = shared(np.int8([7]), strict=True)
         assert b.type == theano.tensor.bvector
         self.assertRaises(TypeError, f, b, 8.23)
 
-        b = shared(numpy.float64([7.234]), strict=True)
+        b = shared(np.float64([7.234]), strict=True)
         assert b.type == theano.tensor.dvector
         self.assertRaises(TypeError, f, b, 8)
 
-        b = shared(numpy.float32([7.234]), strict=True)
+        b = shared(np.float32([7.234]), strict=True)
         assert b.type == theano.tensor.fvector
         self.assertRaises(TypeError, f, b, 8)
 
-# numpy.float([7.234]) don't work
-#        b = shared(numpy.float([7.234]), strict=True)
+# np.float([7.234]) don't work
+#        b = shared(np.float([7.234]), strict=True)
 #        assert b.type == theano.tensor.dvector
 #        self.assertRaises(TypeError, f, b, 8)
 
@@ -188,8 +188,8 @@ class Test_SharedVariable(unittest.TestCase):
 #        assert b.type == theano.tensor.dvector
 #        self.assertRaises(TypeError, f, b, 8)
 
-        b = shared(numpy.zeros((5, 5), dtype='float32'))
-        self.assertRaises(TypeError, f, b, numpy.random.rand(5, 5))
+        b = shared(np.zeros((5, 5), dtype='float32'))
+        self.assertRaises(TypeError, f, b, np.random.rand(5, 5))
 
     def test_scalar_floatX(self):
 
@@ -204,37 +204,37 @@ class Test_SharedVariable(unittest.TestCase):
         def f(var, val):
             var.set_value(val)
 
-        b = shared(numpy.int64(7), allow_downcast=True)
+        b = shared(np.int64(7), allow_downcast=True)
         assert b.type == theano.tensor.lscalar
         f(b, 8.23)
         assert b.get_value() == 8
 
-        b = shared(numpy.int32(7), allow_downcast=True)
+        b = shared(np.int32(7), allow_downcast=True)
         assert b.type == theano.tensor.iscalar
         f(b, 8.23)
         assert b.get_value() == 8
 
-        b = shared(numpy.int16(7), allow_downcast=True)
+        b = shared(np.int16(7), allow_downcast=True)
         assert b.type == theano.tensor.wscalar
         f(b, 8.23)
         assert b.get_value() == 8
 
-        b = shared(numpy.int8(7), allow_downcast=True)
+        b = shared(np.int8(7), allow_downcast=True)
         assert b.type == theano.tensor.bscalar
         f(b, 8.23)
         assert b.get_value() == 8
 
-        b = shared(numpy.float64(7.234), allow_downcast=True)
+        b = shared(np.float64(7.234), allow_downcast=True)
         assert b.type == theano.tensor.dscalar
         f(b, 8)
         assert b.get_value() == 8
 
-        b = shared(numpy.float32(7.234), allow_downcast=True)
+        b = shared(np.float32(7.234), allow_downcast=True)
         assert b.type == theano.tensor.fscalar
         f(b, 8)
         assert b.get_value() == 8
 
-        b = shared(numpy.float(7.234), allow_downcast=True)
+        b = shared(np.float(7.234), allow_downcast=True)
         assert b.type == theano.tensor.dscalar
         f(b, 8)
         assert b.get_value() == 8
@@ -244,45 +244,45 @@ class Test_SharedVariable(unittest.TestCase):
         f(b, 8)
         assert b.get_value() == 8
 
-        b = shared(numpy.zeros((5, 5), dtype='float32'))
-        self.assertRaises(TypeError, f, b, numpy.random.rand(5, 5))
+        b = shared(np.zeros((5, 5), dtype='float32'))
+        self.assertRaises(TypeError, f, b, np.random.rand(5, 5))
 
     def test_tensor_floatX(self):
         def f(var, val):
             var.set_value(val)
 
-        b = shared(numpy.int64([7]), allow_downcast=True)
+        b = shared(np.int64([7]), allow_downcast=True)
         assert b.type == theano.tensor.lvector
         f(b, [8.23])
         assert b.get_value() == 8
 
-        b = shared(numpy.int32([7]), allow_downcast=True)
+        b = shared(np.int32([7]), allow_downcast=True)
         assert b.type == theano.tensor.ivector
         f(b, [8.23])
         assert b.get_value() == 8
 
-        b = shared(numpy.int16([7]), allow_downcast=True)
+        b = shared(np.int16([7]), allow_downcast=True)
         assert b.type == theano.tensor.wvector
         f(b, [8.23])
         assert b.get_value() == 8
 
-        b = shared(numpy.int8([7]), allow_downcast=True)
+        b = shared(np.int8([7]), allow_downcast=True)
         assert b.type == theano.tensor.bvector
         f(b, [8.23])
         assert b.get_value() == 8
 
-        b = shared(numpy.float64([7.234]), allow_downcast=True)
+        b = shared(np.float64([7.234]), allow_downcast=True)
         assert b.type == theano.tensor.dvector
         f(b, [8])
         assert b.get_value() == 8
 
-        b = shared(numpy.float32([7.234]), allow_downcast=True)
+        b = shared(np.float32([7.234]), allow_downcast=True)
         assert b.type == theano.tensor.fvector
         f(b, [8])
         assert b.get_value() == 8
 
-# numpy.float([7.234]) don't work
-#        b = shared(numpy.float([7.234]))
+# np.float([7.234]) don't work
+#        b = shared(np.float([7.234]))
 #        assert b.type == theano.tensor.dvector
 #        f(b,[8])
 
@@ -291,15 +291,15 @@ class Test_SharedVariable(unittest.TestCase):
 #        assert b.type == theano.tensor.dvector
 #        f(b,[8])
 
-        b = shared(numpy.asarray([7.234], dtype=theano.config.floatX),
+        b = shared(np.asarray([7.234], dtype=theano.config.floatX),
                    allow_downcast=True)
         assert b.dtype == theano.config.floatX
         f(b, [8])
         assert b.get_value() == 8
 
-        b = shared(numpy.zeros((5, 5), dtype='float32'))
-        self.assertRaises(TypeError, f, b, numpy.random.rand(5, 5))
+        b = shared(np.zeros((5, 5), dtype='float32'))
+        self.assertRaises(TypeError, f, b, np.random.rand(5, 5))
 
     def test_err_symbolic_variable(self):
         self.assertRaises(TypeError, shared, theano.tensor.ones((2, 3)))
-        shared(numpy.ones((2, 4)))
+        shared(np.ones((2, 4)))