Merge pull request #1875 from Hengjean/TypedListC

theano/typed_list/__init__.py

 from type import TypedListType
 from basic import *
+import opt

theano/typed_list/opt.py

+from theano import gof
+from theano import compile
+from theano.gof import TopoOptimizer
+from theano.typed_list.basic import (Reverse,
+                    Append, Extend, Insert, Remove)
+
+
+@gof.local_optimizer([Append, Extend, Insert, Reverse, Remove], inplace=True)
+def typed_list_inplace_opt(node):
+    if isinstance(node.op, (Append, Extend, Insert, Reverse, Remove)) \
+                                        and not node.op.inplace:
+
+        new_op = node.op.__class__(
+                    inplace=True)
+        new_node = new_op(*node.inputs)
+        return [new_node]
+    return False
+compile.optdb.register('typed_list_inplace_opt',
+                       TopoOptimizer(typed_list_inplace_opt,
+    failure_callback=TopoOptimizer.warn_inplace), 60,
+                       'fast_run', 'inplace')

theano/typed_list/tests/test_opt.py

+import unittest
+
+import numpy
+
+import theano
+import theano.typed_list
+from theano import tensor as T
+from theano.tensor.type_other import SliceType
+from theano.typed_list.type import TypedListType
+from theano.typed_list.basic import (GetItem, Insert,
+                                      Append, Extend, Remove, Reverse,
+                                      Index, Count)
+from theano import In
+
+
+#took from tensors/tests/test_basic.py
+def rand_ranged_matrix(minimum, maximum, shape):
+    return numpy.asarray(numpy.random.rand(*shape) * (maximum - minimum)
+                         + minimum, dtype=theano.config.floatX)
+
+
+class test_inplace(unittest.TestCase):
+
+    def test_reverse_inplace(self):
+        mySymbolicMatricesList = TypedListType(T.TensorType(
+                                theano.config.floatX, (False, False)))()
+
+        z = Reverse()(mySymbolicMatricesList)
+        m = theano.compile.mode.get_default_mode().including("typed_list_inplace_opt")
+        f = theano.function([In(mySymbolicMatricesList, borrow=True,
+                        mutable=True)], z, accept_inplace=True, mode=m)
+        self.assertTrue(f.maker.fgraph.toposort()[0].op.inplace)
+
+        x = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        y = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        self.assertTrue(numpy.array_equal(f([x, y]), [y, x]))
+
+    def test_append_inplace(self):
+        mySymbolicMatricesList = TypedListType(T.TensorType(
+                                theano.config.floatX, (False, False)))()
+        mySymbolicMatrix = T.matrix()
+        z = Append()(mySymbolicMatricesList, mySymbolicMatrix)
+        m = theano.compile.mode.get_default_mode().including("typed_list_inplace_opt")
+        f = theano.function([In(mySymbolicMatricesList, borrow=True,
+                        mutable=True), In(mySymbolicMatrix, borrow=True,
+                        mutable=True)], z, accept_inplace=True, mode=m)
+        self.assertTrue(f.maker.fgraph.toposort()[0].op.inplace)
+
+        x = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        y = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        self.assertTrue(numpy.array_equal(f([x], y), [x, y]))
+
+    def test_extend_inplace(self):
+        mySymbolicMatricesList1 = TypedListType(T.TensorType(
+                                theano.config.floatX, (False, False)))()
+
+        mySymbolicMatricesList2 = TypedListType(T.TensorType(
+                                theano.config.floatX, (False, False)))()
+
+        z = Extend()(mySymbolicMatricesList1, mySymbolicMatricesList2)
+        m = theano.compile.mode.get_default_mode().including("typed_list_inplace_opt")
+        f = theano.function([In(mySymbolicMatricesList1, borrow=True,
+                    mutable=True), mySymbolicMatricesList2],
+                            z, mode=m)
+        self.assertTrue(f.maker.fgraph.toposort()[0].op.inplace)
+
+        x = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        y = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        self.assertTrue(numpy.array_equal(f([x], [y]), [x, y]))
+
+    def test_insert_inplace(self):
+        mySymbolicMatricesList = TypedListType(T.TensorType(
+                                theano.config.floatX, (False, False)))()
+        mySymbolicIndex = T.scalar(dtype='int64')
+        mySymbolicMatrix = T.matrix()
+
+        z = Insert()(mySymbolicMatricesList, mySymbolicIndex, mySymbolicMatrix)
+        m = theano.compile.mode.get_default_mode().including("typed_list_inplace_opt")
+
+        f = theano.function([In(mySymbolicMatricesList, borrow=True,
+                        mutable=True), mySymbolicIndex, mySymbolicMatrix],
+                        z, accept_inplace=True, mode=m)
+        self.assertTrue(f.maker.fgraph.toposort()[0].op.inplace)
+
+        x = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        y = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        self.assertTrue(numpy.array_equal(f([x], numpy.asarray(1,
+                                dtype='int64'), y), [x, y]))
+
+    def test_remove_inplace(self):
+        mySymbolicMatricesList = TypedListType(T.TensorType(
+                                    theano.config.floatX, (False, False)))()
+        mySymbolicMatrix = T.matrix()
+        z = Remove()(mySymbolicMatricesList, mySymbolicMatrix)
+        m = theano.compile.mode.get_default_mode().including("typed_list_inplace_opt")
+        f = theano.function([In(mySymbolicMatricesList, borrow=True,
+                            mutable=True), In(mySymbolicMatrix, borrow=True,
+                            mutable=True)], z, accept_inplace=True, mode=m)
+        self.assertTrue(f.maker.fgraph.toposort()[0].op.inplace)
+
+        x = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        y = rand_ranged_matrix(-1000, 1000, [100, 101])
+
+        self.assertTrue(numpy.array_equal(f([x, y], y), [x]))

theano/typed_list/type.py

@@ -65,3 +65,46 @@ class TypedListType(gof.Type):
             return self.ttype.get_depth() + 1
         else:
             return 0
+
+    def values_eq(self, a, b):
+        if not len(a) == len(b):
+            return False
+
+        for x in range(len(a)):
+            if not self.ttype.values_eq(a[x], b[x]):
+                return False
+
+        return True
+
+    def c_declare(self, name, sub):
+        return """
+        PyListObject* %(name)s;
+        """ % dict(name=name)
+
+    def c_init(self, name, sub):
+        return """
+        %(name)s = NULL;
+        """ % dict(name=name)
+
+    def c_extract(self, name, sub):
+        return """
+        if (!PyList_Check(py_%(name)s)) {
+            PyErr_SetString(PyExc_TypeError, "expected a list");
+            %(fail)s
+        }
+        %(name)s = (PyListObject*) (py_%(name)s);
+        """ % dict(name=name, fail=sub['fail'])
+
+    def c_sync(self, name, sub):
+
+        return """
+        Py_XDECREF(py_%(name)s);
+        py_%(name)s = (PyObject*)(%(name)s);
+        Py_INCREF(py_%(name)s);
+        """ % dict(name=name)
+
+    def c_cleanup(self, name, sub):
+        return ""
+
+    def c_code_cache_version(self):
+        return (1,)