Datasets:

xPXXX

/

stackoverflow_DL-related_questions

like 0

[ { "AnswerId": "9254474", "CreationDate": "2012-02-13T01:20:28.603", "ParentId": null, "OwnerUserId": "221509", "Title": null, "Body": "<p>I'm not sure if it is comparable to Scipy, but there is <a href=\"http://www.nongnu.org/gsl-shell/\" rel=\"nofollow\">GSL Shell</a> which is based on LuaJIT and GNU Scientific Library, which offers many numerical algorithms and vector/matrix linear algebra operations.</p>\n" }, { "AnswerId": "9253469", "CreationDate": "2012-02-12T22:52:02.930", "ParentId": null, "OwnerUserId": "1205758", "Title": null, "Body": "<p>There's a Numpy-like extension for Lua which runs without dependencies at</p>\n\n<p><a href=\"https://github.com/jzrake/lunum\" rel=\"nofollow\">https://github.com/jzrake/lunum</a></p>\n\n<p>In the future it will provide FFT's and linear algebra like Numpy+Scipy. Presently it supports numeric array manipulation like in Numpy.</p>\n" }, { "AnswerId": "18776865", "CreationDate": "2013-09-13T01:33:04.577", "ParentId": null, "OwnerUserId": "18403", "Title": null, "Body": "<p>You have some options:</p>\n\n<ul>\n<li><a href=\"http://numlua.luaforge.net/\" rel=\"noreferrer\">Numeric Lua</a> - C module for Lua 5.1/5.2, provides matrices, FFT, complex numbers and others</li>\n<li><a href=\"http://www.nongnu.org/gsl-shell/\" rel=\"noreferrer\">GSL Shell</a> - Modification of Lua (supports Lua libraries) with a nice syntax. Provides almost everything that Numeric Lua does, plus ODE solvers, plotting capabilities, and other nice things. Has a great documentation.</li>\n<li><a href=\"http://www.scilua.org/\" rel=\"noreferrer\">SciLua</a> - Pure LuaJIT module. Aims to be a complete framework for scientific computing in Lua. Provides vectors and matrices, random numbers / distributions, optimization, others. Still in early development.</li>\n<li><a href=\"https://bitbucket.org/lucashnegri/lna\" rel=\"noreferrer\">Lua Numerical Algorithms</a> - Pure LuaJIT module (uses blas/lapack via LuaJIT FFI). Provides matrices / linear algebra, FFT, complex numbers, optimization algorithms, ODE solver, basic statistics (+ PCA, LDA), and others. Still in early development, but has a somewhat complete documentation and test suits.</li>\n</ul>\n" }, { "AnswerId": "10631596", "CreationDate": "2012-05-17T07:30:57.633", "ParentId": null, "OwnerUserId": "1400386", "Title": null, "Body": "<p>You should try <strong><a href=\"http://www.torch.ch\" rel=\"noreferrer\">Torch7</a></strong> (<a href=\"https://github.com/andresy/torch\" rel=\"noreferrer\">github</a>).</p>\n\n<p>Torch7 has a very nice and efficient vector/matrix/tensor numerical library\nwith a Lua front-end. It also has a bunch of functions for computer vision\nand machine learning. </p>\n\n<p>It's pretty recent but getting better quickly.</p>\n" }, { "AnswerId": "388184", "CreationDate": "2008-12-23T04:36:07.220", "ParentId": null, "OwnerUserId": "33252", "Title": null, "Body": "<p>There is the basis for one in <a href=\"http://numlua.luaforge.net/\" rel=\"nofollow noreferrer\">Numeric Lua</a>.</p>\n" }, { "AnswerId": "388587", "CreationDate": "2008-12-23T10:33:39.823", "ParentId": null, "OwnerUserId": "17160", "Title": null, "Body": "<p>One can always use <a href=\"http://labix.org/lunatic-python\" rel=\"noreferrer\">Lunatic Python</a> and access scipy inside lua.</p>\n\n<pre><code>&gt; require(\"python\")\n&gt; numpy = python.import(\"numpy\")\n&gt; numpy.array ... etc ..\n</code></pre>\n" } ]

[ { "AnswerId": "18241213", "CreationDate": "2013-08-14T20:03:51.183", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>A better fix is to remove atlas and install openblas. openblas is faster then atlas. Also, openblas don't request gfortran and is the one numpy was linked with. So it will work out of the box.</p>\n" }, { "AnswerId": "18238732", "CreationDate": "2013-08-14T17:48:02.127", "ParentId": null, "OwnerUserId": "430281", "Title": null, "Body": "<p>I had the same problem, and after reviewing the source code, user212658's answer seemed like it would work (I have not tried it). I then looked for a way to deploy user212658's hack without modifying the source code.</p>\n\n<p>Put these lines in your <a href=\"http://deeplearning.net/software/theano/library/config.html#envvar-THEANORC\">theanorc</a> file:</p>\n\n<pre><code>[blas]\nldflags = -lblas -lgfortran\n</code></pre>\n\n<p>This worked for me.</p>\n" }, { "AnswerId": "12142579", "CreationDate": "2012-08-27T13:06:16.947", "ParentId": null, "OwnerUserId": "1491200", "Title": null, "Body": "<p>Have you tried to recompile NumPy from the sources? </p>\n\n<p>I'm not familiar with the Ubuntu package system, so I can't check what's in your <code>dist-packages/numpy</code>. With a clean archive of the <code>NumPy</code> sources, you should have a <code>setup.py</code> at the same level as the directories <code>numpy</code>, <code>tools</code> and <code>benchmarks</code> (among others). I'm pretty sure that's the one you want to use for a <code>python setup.py build</code>.</p>\n\n<p><strong>[EDIT]</strong></p>\n\n<p>Now that you have recompiled <code>numpy</code> with the proper <code>--fcompiler</code> option, perhaps could you try to do the same with <code>Theano</code>, that is, compiling directly from sources <em>without</em> relying on a <code>apt-get</code> or even <code>pip</code>. You should have a better control on the build process that way, which will make debugging/trying to find a solution easier. </p>\n" }, { "AnswerId": "13579399", "CreationDate": "2012-11-27T07:34:10.480", "ParentId": null, "OwnerUserId": "212658", "Title": null, "Body": "<p>I had the same problem. The solution I found is to add a hack in theano/gof/cmodule.py to link against gfortran whenever 'blas' is in the libs. That fixed it.</p>\n\n<pre><code>class GCC_compiler(object):\n ...\n @staticmethod\n def compile_str(module_name, src_code, location=None,\n include_dirs=None, lib_dirs=None, libs=None,\n preargs=None):\n ...\n cmd.extend(['-l%s' % l for l in libs])\n if 'blas' in libs:\n cmd.append('-lgfortran')\n</code></pre>\n" } ]

[ { "AnswerId": "20026491", "CreationDate": "2013-11-17T02:34:11.297", "ParentId": null, "OwnerUserId": "179081", "Title": null, "Body": "<p>Theano, seeks to improve NumPy,\nNumPy is a prerequisite for Theano.</p>\n\n<p>A large feature of Theano, is it's transparent use of CUDA GPU's, when possible.</p>\n" }, { "AnswerId": "13762698", "CreationDate": "2012-12-07T12:01:37.330", "ParentId": null, "OwnerUserId": "1098041", "Title": null, "Body": "<p>Well for one thing : millions of lines of code use numpy, so porting Numpy to pypy would be a great step forward for the porting of many other (scientific and other) librairies to Pypy.</p>\n\n<p>Re-implementing all Numpy in pypy may sound like a chore, and it is, but the alternative in just insane : re-implementing hundreds or librairies to use XXX instead.</p>\n\n<p>And by the way I don't know theano really well, but I know it isn't a substitute for Numpy.\nthey are different projects, with different features.</p>\n" } ]

[ { "AnswerId": "16868431", "CreationDate": "2013-06-01T02:15:08.277", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Everybody I know do the loop over minibatch in python. This can be done with scan, but all your tries here did not used scan. So it is normal that they didn't worked. You need to call the scan function somewhere to use it (or its higher level interface like map). In fact, in your case, I think you can use <code>theano.scan(fn, theano.tensor.arange(N))</code>.</p>\n\n<p>I can't answer all your questions in this post as the snippet of code is incomplete, but here is some information:</p>\n\n<pre><code>return theano.function(\n inputs=[], outputs=[self.cost] * n_batches,\n</code></pre>\n\n<p>Here: <code>[self.cost] * n_batches</code> is pure python code. This create a list of <code>n_batches</code> element, where each elements are <code>self.cos</code>t. So if <code>n_batches</code> is 3, you will have <code>outputs=[self.cost, self.cost, self.cost]</code>. That is why you got the same value outputed multiple time.</p>\n\n<p>I can't tell you why you always add the same answer as I need information that wasn't provided.</p>\n" } ]

[ { "AnswerId": "14631722", "CreationDate": "2013-01-31T17:33:43.570", "ParentId": null, "OwnerUserId": "359944", "Title": null, "Body": "<p>Try </p>\n\n<pre><code>from theano import config\nconfig.warn.sum_div_dimshuffle_bug = False\n</code></pre>\n\n<p>This worked for me</p>\n" } ]

[ { "AnswerId": "37846374", "CreationDate": "2016-06-15T21:48:49.483", "ParentId": null, "OwnerUserId": "2534758", "Title": null, "Body": "<p>You can try installing mingw (<a href=\"http://www.mingw.org/\" rel=\"nofollow noreferrer\">http://www.mingw.org/</a>) as mentioned in the answer posted here - <a href=\"https://stackoverflow.com/questions/36722975/theano-g-not-detected/37846308#37846308\">theano g++ not detected</a></p>\n" }, { "AnswerId": "15542158", "CreationDate": "2013-03-21T08:00:17.403", "ParentId": null, "OwnerUserId": "1060350", "Title": null, "Body": "<p>Try installing the <code>g++</code> compiler.</p>\n\n<p>Python is rather slow, so for performance-critical parts you need a compiled language such as C++.</p>\n" } ]

[ { "AnswerId": "19216429", "CreationDate": "2013-10-07T02:56:48.000", "ParentId": null, "OwnerUserId": "1319683", "Title": null, "Body": "<p>Use <a href=\"http://deeplearning.net/software/theano/library/tensor/basic.html#theano.tensor.set_subtensor\" rel=\"noreferrer\">set_subtensor</a> or <a href=\"http://deeplearning.net/software/theano/library/tensor/basic.html#theano.tensor.inc_subtensor\" rel=\"noreferrer\">inc_subtensor</a>:</p>\n\n<pre><code>from theano import tensor as T\nfrom theano import function, shared\nimport numpy\n\nX = shared(numpy.array([0,1,2,3,4]))\nY = T.vector()\nX_update = (X, T.set_subtensor(X[2:4], Y))\nf = function([Y], updates=[X_update])\nf([100,10])\nprint X.get_value() # [0 1 100 10 4]\n</code></pre>\n\n<p>There's now a page about this in the Theano FAQ: <a href=\"http://deeplearning.net/software/theano/tutorial/faq_tutorial.html\" rel=\"noreferrer\">http://deeplearning.net/software/theano/tutorial/faq_tutorial.html</a></p>\n" }, { "AnswerId": "16739636", "CreationDate": "2013-05-24T16:28:42.940", "ParentId": null, "OwnerUserId": "380038", "Title": null, "Body": "<p>This code should solve your problem:</p>\n\n<pre><code>from theano import tensor as T\nfrom theano import function, shared\nimport numpy\n\nX = shared(numpy.array([0,1,2,3,4], dtype='int'))\nY = T.lvector()\nX_update = (X, X[2:4]+Y)\nf = function(inputs=[Y], updates=[X_update])\nf([100,10])\nprint X.get_value()\n# output: [102 13]\n</code></pre>\n\n<p>And here is the <a href=\"http://deeplearning.net/software/theano/tutorial/examples.html#using-shared-variables\" rel=\"nofollow\">introduction about shared variables in the official tutorial</a>.</p>\n\n<p>Please ask, if you have further questions!</p>\n" } ]

[ { "AnswerId": "16446170", "CreationDate": "2013-05-08T16:56:35.097", "ParentId": null, "OwnerUserId": "413345", "Title": null, "Body": "<p>This turns out to be a Theano bug as of mid-Feb. 2013 (0.6.0rc-2). It is fixed in the development version on github as of the date of this post.</p>\n" } ]

[ { "AnswerId": "16868378", "CreationDate": "2013-06-01T02:06:05.347", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Installation on Windows isn't trivial. The simplest way is to use EPD(not the free version, it miss some depenency). Are you an academic? If so, it is free. It install all Theano dependency, so you only need to install Theano after that and we link to MKL for BLAS.</p>\n\n<p><a href=\"https://www.enthought.com/products/epd\" rel=\"nofollow\">https://www.enthought.com/products/epd</a></p>\n\n<p>We had an Theano installer that worked with Anaconda 1.4, but the newer released Anaconda 1.5 broke it. We haven't repaired it yet.</p>\n" } ]

[ { "AnswerId": "16926207", "CreationDate": "2013-06-04T19:45:34.950", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Following @RobertKern@ information, it is now fixed in the development version of Theano.</p>\n\n<p>To update to the development version, do:</p>\n\n<pre><code>pip -U --no-deps git+git://github.com/Theano/Theano.git\n</code></pre>\n" } ]

[ { "AnswerId": "16641107", "CreationDate": "2013-05-20T00:51:03.093", "ParentId": null, "OwnerUserId": "1330293", "Title": null, "Body": "<p>You probably have an old version of Theano; <code>stacklist</code> was <a href=\"https://github.com/mrocklin/Theano/commit/8eefe5a0094e84d470865e42cc16edcbdeda58e3\" rel=\"nofollow\">recently introduced/renamed</a> (a month ago). Sou you should update to the latest/dev version. If you want to stay in your version try importing <code>tensor_of_scalars</code> instead of <code>stacklist</code>.</p>\n\n<p>To update follow the instructions <a href=\"http://deeplearning.net/software/theano/install.html#install\" rel=\"nofollow\">here</a>.</p>\n" }, { "AnswerId": "16641059", "CreationDate": "2013-05-20T00:43:30.710", "ParentId": null, "OwnerUserId": "1103045", "Title": null, "Body": "<p>This error can be caused by one of two things.</p>\n\n<p>The first one is pretty obvious: does <code>theano.tensor</code> define a name <code>stacklists</code>? Should it be, for example, <code>stacklist</code>?</p>\n\n<p>Secondly, it can happen if something else you're importing has already imported the name in a way where doing so again would cause a circular reference. The second would have to be fixed by looking at your source files.</p>\n" } ]

[ { "AnswerId": "39842355", "CreationDate": "2016-10-04T00:15:59.297", "ParentId": null, "OwnerUserId": "6901690", "Title": null, "Body": "<p>I got the same error and I did the following sequence to make it work, in a Python 3:</p>\n\n<pre><code>source activate anaconda\npip install pydot\npip install pydotplus\npip install pydot-ng\n</code></pre>\n\n<p>Then you download and install Graphviz from here according to your OS type:\n<a href=\"http://www.graphviz.org/Download..php\" rel=\"nofollow noreferrer\">http://www.graphviz.org/Download..php</a></p>\n\n<p>If you are running Python on Anaconda, open Spyder from terminal, not from Anaconda. Go to terminal and type:</p>\n\n<pre><code>spyder\n</code></pre>\n\n<p>Then:</p>\n\n<pre><code>import theano\nimport theano.tensor as T\n.\n.\n.\nimport pydot\nimport graphviz\nimport pydot_ng as pydot\n</code></pre>\n\n<p>Develop your model and:</p>\n\n<pre><code>theano.printing.pydotprint(prediction, outfile=\"/Volumes/Python/prediction.png\", var_with_name_simple=True)\n</code></pre>\n\n<p>You will have a picture like this:\n<a href=\"https://i.stack.imgur.com/CO8GR.png\" rel=\"nofollow noreferrer\"><img src=\"https://i.stack.imgur.com/CO8GR.png\" alt=\"enter image description here\"></a></p>\n" }, { "AnswerId": "21513225", "CreationDate": "2014-02-02T16:46:32.297", "ParentId": null, "OwnerUserId": "3262258", "Title": null, "Body": "<p>I also have the same issue. I would suggest you post this in the Github Theano Issues forum:</p>\n\n<p><a href=\"https://github.com/Theano/Theano/issues?direction=desc&amp;sort=updated&amp;state=open\" rel=\"nofollow\">https://github.com/Theano/Theano/issues?direction=desc&amp;sort=updated&amp;state=open</a></p>\n\n<p>It seems to me, that since this instance of the pydotprint() function is actually part of the printing module within the Theano library that this should not be an issue (but it is) and hence it should be brought to the attention of the developers in order to fix it.</p>\n\n<p>Please correct me if this is not the case.</p>\n" }, { "AnswerId": "16683692", "CreationDate": "2013-05-22T04:51:24.647", "ParentId": null, "OwnerUserId": "2318122", "Title": null, "Body": "<p>It mainly depends on where you put the pydot files. If you are running it straight from the Python Shell then you should have them installed in the modules folder which is most commonly the \"Lib\" folder inside the main python folder.</p>\n" } ]

[ { "AnswerId": "16782594", "CreationDate": "2013-05-28T01:33:56.643", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>You need to change the compilation line to this one:</p>\n\n<pre><code>Tsumprod = theano.function([], outputs=Tsumprod_result)\n</code></pre>\n\n<p>theano.function() always need a list of inputs. If the function take 0 input, like in this case, you need to give an empty list for the inputs.</p>\n" } ]

[ { "AnswerId": "16787359", "CreationDate": "2013-05-28T08:29:27.513", "ParentId": null, "OwnerUserId": "380038", "Title": null, "Body": "<p>From: <a href=\"https://stackoverflow.com/a/16782594/380038\">https://stackoverflow.com/a/16782594/380038</a></p>\n\n<p>\"<code>theano.function()</code> always needs a list of inputs. If the function takes 0 input, like in this case, you need to give an empty list for the inputs.\"</p>\n\n<p><code>f2 = th.function(outputs=z)</code> has to be <code>f2 = th.function([], outputs=z)</code></p>\n" } ]

[ { "AnswerId": "16815974", "CreationDate": "2013-05-29T14:00:42.667", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>First, there is more people that will answer your questions on theano mailing list then on stackoverflow. But I'm here:)</p>\n\n<p>First, your function isn't a good fit for GPU. Even if everything was well optimized, the transfer of the input to the gpu just to add and sum the result will take more time to run then the python version.</p>\n\n<p>Your python code is slow, here is a version that should be faster:</p>\n\n<pre><code>def sumprod(a1, a2):\n \"\"\"Sum the element-wise products of the `a1` and `a2`.\"\"\"\n a1 = numpy.asarray(a1)\n a2 = numpy.asarray(a2)\n result (a1 * a2).sum(axis=0)\n return result\n</code></pre>\n\n<p>For the theano code, here is the equivalent of this faster python version(no need of scan)</p>\n\n<pre><code>m1 = theano.tensor.matrix()\nm2 = theano.tensor.matrix()\nf = theano.function([m1, m2], (m1 * m2).sum(axis=0))\n</code></pre>\n\n<p>The think to remember from this is that you need to \"vectorize\" your code. The \"vectorize\" is used in the NumPy context and it mean to use numpy.ndarray and use function that work on the full tensor at a time. This is always faster then doing it with loop (python loop or theano scan). Also, Theano optimize some of thoses cases by moving the computation outside the scan, but it don't always do it.</p>\n" } ]

[ { "AnswerId": "16860115", "CreationDate": "2013-05-31T14:51:21.860", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>You are using a version of Theano that is too old. In fact, tensor_var.nonzero() isn't in any released version. You need to update to the development version.</p>\n\n<p>With the development version I have this:</p>\n\n<pre><code>&gt;&gt;&gt; that[~(that&gt;=5).nonzero()].max().eval()\nTraceback (most recent call last):\n File \"&lt;stdin&gt;\", line 1, in &lt;module&gt;\nTypeError: bad operand type for unary ~: 'tuple'\n</code></pre>\n\n<p>This is because you are missing parenthesis in your line. Here is the good line:</p>\n\n<pre><code>&gt;&gt;&gt; that[(~(that&gt;=5)).nonzero()].max().eval()\narray(9, dtype=int32)\n</code></pre>\n\n<p>But we still have unexpected result! The problem is that Theano do not support bool. Doing ~ on int8, is doing the bitwise invert on 8 bits, not 1 bit. It give this result:</p>\n\n<pre><code>&gt;&gt;&gt; (that&gt;=5).eval()\narray([0, 0, 0, 0, 0, 1, 1, 1, 1, 1], dtype=int8)\n&gt;&gt;&gt; (~(that&gt;=5)).eval()\narray([-1, -1, -1, -1, -1, -2, -2, -2, -2, -2], dtype=int8)\n</code></pre>\n\n<p>You can remove the ~ with this:</p>\n\n<pre><code>&gt;&gt;&gt; that[(that&lt;5).nonzero()].max().eval()\narray(4, dtype=int32)\n</code></pre>\n" } ]

[ { "AnswerId": "17026497", "CreationDate": "2013-06-10T14:39:54.977", "ParentId": null, "OwnerUserId": "380038", "Title": null, "Body": "<p><code>Updates</code> must contain <code>a list of pairs</code>. See official tutorial on <a href=\"http://deeplearning.net/software/theano/tutorial/examples.html#using-shared-variables\" rel=\"nofollow\">using shared variables</a>.</p>\n\n<p>Correct code:</p>\n\n<pre><code>import theano as th\nimport theano.tensor as T\nimport numpy as np\n\nx = T.dscalars('x')\nz = th.shared(np.zeros(2))\nupdates = [(z, z+x)]\n\nf1 = th.function(inputs=[x], updates=updates) \nf1(3)\nprint z.get_value()\n</code></pre>\n" } ]

[ { "AnswerId": "17296524", "CreationDate": "2013-06-25T11:49:33.330", "ParentId": null, "OwnerUserId": "857617", "Title": null, "Body": "<p>You can use the givens keyword in theano.function for that. Basically, you do the following.</p>\n\n<pre class=\"lang-py prettyprint-override\"><code>m1 = theano.shared(name='m1', value = np.zeros((3,2)) )\nm2 = theano.shared(name='m2', value = np.zeros((3,2)) )\n\nx1 = theano.tensor.dmatrix('x1')\nx2 = theano.tensor.dmatrix('x2')\n\ny = (x1*x2).sum(axis=0)\nf = theano.function([],y,givens=[(x1,m1),(x2,m2)],on_unused_input='ignore')\n</code></pre>\n\n<p>then to loop through values you just set the value of the shared variables to the value you'd like. You have to set the on_unused_input to 'ignore' to use functions with no arguments in theano, by the way. Like this:</p>\n\n<pre class=\"lang-py prettyprint-override\"><code>array1 = array([[1,2,3],[4,5,6]])\narray2 = array([[2,4,6],[8,10,12]])\n\nfor i in range(10):\n m1.set_value(i*array1)\n m2.set_value(i*array2)\n print f()\n</code></pre>\n\n<p>It should work, at least that's how I've been working around it.</p>\n" }, { "AnswerId": "17045919", "CreationDate": "2013-06-11T13:54:41.687", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Currently it is not easily possible to reuse a Theano function with different shared variable.</p>\n\n<p>But you have alternative:</p>\n\n<ol>\n<li>Is it really a bottleneck? In the example, it is, but I suppose it is a simplified case. The only way to know is to profile it.</li>\n<li>You compile 1 Theano function with the first shared variable. Then you can call the get_value/set_value on those shared variables before calling the Theano function. This way, you won't need to recompile the Theano function.</li>\n</ol>\n" } ]

[ { "AnswerId": "17134799", "CreationDate": "2013-06-16T15:24:24.933", "ParentId": null, "OwnerUserId": "1961354", "Title": null, "Body": "<p>I solved this problem by adding Visual C++ Compilers feature to my current VS2010 installtion.\nNow I can import theano and console shows that I use gpu</p>\n\n<pre><code>&gt;&gt;import theano\nForcing DISTUTILS_USE_SDK=1\nUsing gpu device 0: GeForce GT 630M\n</code></pre>\n\n<p>But when I am trying to run this code:</p>\n\n<pre><code>from theano import function, config, shared, sandbox\nimport theano.tensor as T\nimport numpy\nimport time\n\nvlen = 10 * 30 * 768 # 10 x #cores x # threads per core\niters = 1000\n\nrng = numpy.random.RandomState(22)\nx = shared(numpy.asarray(rng.rand(vlen), config.floatX))\nf = function([], T.exp(x),mode='DebugMode')\n</code></pre>\n\n<p>I get \n<code>NVCC: nvcc : fatal error : Could not set up the environment for Microsoft Visual Studio using 'c:/Program Files (x86)/Microsoft Visual Studio 10.0/VC/bin/../../VC/bin/amd64/vcvars64.bat</code></p>\n" }, { "AnswerId": "37846439", "CreationDate": "2016-06-15T21:53:14.907", "ParentId": null, "OwnerUserId": "2534758", "Title": null, "Body": "<p>Instead of using git command to install Theano try downloading the zip from the theano repository on GitHub. To install theano, use <code>python setup.py install</code> command. \nAlso try using Anaconda distribution to install Python3.4 or older versions. Then use <code>conda install</code> command to install mingw for g++ support.</p>\n" }, { "AnswerId": "17132910", "CreationDate": "2013-06-16T11:38:28.800", "ParentId": null, "OwnerUserId": "1961354", "Title": null, "Body": "<p>The problem was that I installed Enthought Canopy and it does not contain mingw. The issue can be solved by installing Enthought Python Distribution. Following <a href=\"https://stackoverflow.com/questions/2970493/cuda-linking-error-visual-express-2008-nvcc-fatal-due-to-null-configuratio\">CUDA linking error - Visual Express 2008</a> I created vcvars64.bat in \nc:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\bin\\amd64\\ to avoid nvcc fatal : Visual Studio configuration file '(null)' error.\n But now I get this exception:</p>\n\n<pre><code>c:\\program files (x86)\\microsoft visual studio 10.0\\vc\\include\\codeanalysis\\sourceannotations.h(29): error: invalid redeclaration of type name \"size_t\"\n</code></pre>\n" }, { "AnswerId": "17149578", "CreationDate": "2013-06-17T14:06:54.983", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The problem isn't with Theano, but with nvcc. For Theano to use the GPU, it need a working nvcc installation. But it is not the case currently.</p>\n\n<p>To help you fix this problem, try to compile nvcc example. They will also fail. When you fix this problem, Theano will work. For this, check nvcc installation/tests documentations.</p>\n\n<p>I suspecct that you didn't used the right microsoft compiler version. nvcc don't accept version of msvc.</p>\n" } ]

[ { "AnswerId": "17323199", "CreationDate": "2013-06-26T14:39:56.270", "ParentId": null, "OwnerUserId": "64250", "Title": null, "Body": "<p>This is a Python feature called <a href=\"http://www.diveintopython.net/power_of_introspection/optional_arguments.html\" rel=\"nofollow\">named parameters</a>. For functions with optional parameters or many parameters it is helpful to pass the parameters by name, instead of just relying on the order on which they were passed to the function. In your specific case you can see the meaning of the <code>input</code> parameter <a href=\"http://deeplearning.net/tutorial/logreg.html#creating-a-logisticregression-class\" rel=\"nofollow\">here</a>. </p>\n" }, { "AnswerId": "17323872", "CreationDate": "2013-06-26T15:09:31.163", "ParentId": null, "OwnerUserId": "1634191", "Title": null, "Body": "<p>Named parameters, or default keyword arguments, like <code>input</code>, <code>n_in</code>, and <code>n_out</code> are useful for several reasons.</p>\n\n<ul>\n<li>If a function/method have many parameters, it becomes easier to pass them by name instead of having to remember the functional order of the parameters.</li>\n<li>Many functions/methods have default use cases which are used often, and specialty use cases which are used rarely. If the specialty use case requires passing additional arguments to the function, those will most likely take the form of named parameters with default values. This way, when the function is used in the default use case, the user does not have to specify any additional parameters. Only when someone wants to use the specialty case will they have to specify something extra. This keeps function and method calls readable and simple when they aren't used in complex or specialty ways.</li>\n</ul>\n" }, { "AnswerId": "17358567", "CreationDate": "2013-06-28T06:29:44.473", "ParentId": null, "OwnerUserId": "857617", "Title": null, "Body": "<p>so... Theano builds graphs for the expressions it computes before evaluating them. By passing a theano variable such as 'x' in the example to the initialization of the logistic regression object, you will create a number of expressions such as p_y_given_x in your object which are theano expressions dependent on x. This is later used for symbolic gradient calculation.</p>\n\n<p>To get a better feel for it you can do the following:</p>\n\n<p></p>\n\n<pre><code>import theano.pp #pp is for pretty print\nx = T.dmatrix('x') #naming your variables is a good idea, and important i think\nlr = LogisticRegression(x,n_in = 28*28, n_out= 10)\nprint pp(lr.p_y_given_x)\n</code></pre>\n\n<p>This should given you an output such as</p>\n\n<pre><code>softmax( W \\dot x + b)\n</code></pre>\n\n<p>And while you're at it go ahead and try out</p>\n\n<p></p>\n\n<pre><code>print pp(T.grad(lr._y_given_x,x)) #might need syntax checkng\n</code></pre>\n\n<p>which is how theano internally stores the expression. Then you can use these expressions to create functions in theano, such as</p>\n\n<p></p>\n\n<pre><code>values = theano.shared( value = mydata, name = 'values')\nf = theano.function([],lr.p_y_given_x , \n givens ={x:values},on_unused_input='ignore')\nprint f()\n</code></pre>\n\n<p>then calling f should give you the predicted class probabilities for the values defined in mydata. The way to do this in theano (and the way it's done in the DL tutorials) is by passing a \"dummy\" theano variable and then using the \"givens\" keyword to set it to a shared variable containing your data. That's important because storing your variables in a shared variable allows theano to use your GPU for matrix operations.</p>\n" } ]

[ { "AnswerId": "17426874", "CreationDate": "2013-07-02T13:26:35.310", "ParentId": null, "OwnerUserId": "832621", "Title": null, "Body": "<p>You can access the data from your sparse matrix as a <code>1D array</code> so that:</p>\n\n<pre><code>ss.data *= -1\nss.data += 1\n</code></pre>\n\n<p>will work like <code>1 - ss</code>, for all non-zero elements in your sparse matrix.</p>\n" }, { "AnswerId": "17427551", "CreationDate": "2013-07-02T13:57:01.747", "ParentId": null, "OwnerUserId": "110026", "Title": null, "Body": "<p>Your new matrix will not be sparse, because it will have <code>1</code>s everywhere, so you will need a dense array to hold it:</p>\n\n<pre><code>new_mat = np.ones(sps_mat.shape, sps_mat.dtype) - sps_mat.todense()\n</code></pre>\n\n<p>This requires that your matrix fits in memory. It actually requires that it fits in memory 3 times. If that is an issue, you can get it to be more efficient doing something like:</p>\n\n<pre><code>new_mat = sps_mat.todense()\nnew_mat *= -1\nnew_mat += 1\n</code></pre>\n" } ]

[ { "AnswerId": "38538089", "CreationDate": "2016-07-23T04:12:09.713", "ParentId": null, "OwnerUserId": "615130", "Title": null, "Body": "<p>print Value of a Tensor Variable.</p>\n\n<p>Do the following:</p>\n\n<p><code>print tensor[dimension].eval()</code> # this will print the content/value at that position in the Tensor</p>\n\n<p>Example, for a 1 d tensor:</p>\n\n<pre><code>print tensor[0].eval()\n</code></pre>\n" }, { "AnswerId": "29963238", "CreationDate": "2015-04-30T08:54:07.183", "ParentId": null, "OwnerUserId": "828368", "Title": null, "Body": "<p>For future readers: the previous answer is quite good. \nBut, I found the 'tag.test_value' mechanism more beneficial for debugging purposes (see <a href=\"http://deeplearning.net/software/theano/tutorial/debug_faq.html#using-test-values\" rel=\"noreferrer\">theano-debug-faq</a>):</p>\n\n<pre><code>from theano import config\nfrom theano import tensor as T\nconfig.compute_test_value = 'raise'\nimport numpy as np \n#define a variable, and use the 'tag.test_value' option:\nx = T.matrix('x')\nx.tag.test_value = np.random.randint(100,size=(5,5))\n\n#define how y is dependent on x:\ny = x*x\n\n#define how some other value (here 'errorCount') depends on y:\nerrorCount = T.sum(y)\n\n#print the tag.test_value result for debug purposes!\nerrorCount.tag.test_value\n</code></pre>\n\n<p>For me, this is much more helpful; e.g., checking correct dimensions etc.</p>\n" }, { "AnswerId": "17453598", "CreationDate": "2013-07-03T16:40:18.020", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>If y is a theano variable, y.shape will be a theano variable. so it is normal that </p>\n\n<pre><code>print y.shape\n</code></pre>\n\n<p>return:</p>\n\n<pre><code>Shape.0\n</code></pre>\n\n<p>If you want to evaluate the expression y.shape, you can do:</p>\n\n<pre><code>y.shape.eval()\n</code></pre>\n\n<p>if <code>y.shape</code> do not input to compute itself(it depend only on shared variable and constant). Otherwise, if <code>y</code> depend on the <code>x</code> Theano variable you can pass the inputs value like this:</p>\n\n<pre><code>y.shape.eval(x=numpy.random.rand(...))\n</code></pre>\n\n<p>this is the same thing for the <code>sum</code>. Theano graph are symbolic variable that do not do computation until you compile it with <code>theano.function</code> or call <code>eval()</code> on them.</p>\n\n<p><strong>EDIT:</strong> Per the <a href=\"http://deeplearning.net/software/theano/library/gof/graph.html#theano.gof.graph.Variable.eval\" rel=\"noreferrer\">docs</a>, the syntax in newer versions of theano is</p>\n\n<pre><code>y.shape.eval({x: numpy.random.rand(...)})\n</code></pre>\n" }, { "AnswerId": "51192683", "CreationDate": "2018-07-05T13:32:34.520", "ParentId": null, "OwnerUserId": "1712419", "Title": null, "Body": "<p>Use <code>theano.printing.Print</code> to add print operator to your computational graph.</p>\n\n<p>Example:</p>\n\n<pre><code>import numpy\nimport theano\n\nx = theano.tensor.dvector('x')\n\nx_printed = theano.printing.Print('this is a very important value')(x)\n\nf = theano.function([x], x * 5)\nf_with_print = theano.function([x], x_printed * 5)\n\n#this runs the graph without any printing\nassert numpy.all( f([1, 2, 3]) == [5, 10, 15])\n\n#this runs the graph with the message, and value printed\nassert numpy.all( f_with_print([1, 2, 3]) == [5, 10, 15])\n</code></pre>\n\n<p>Output:</p>\n\n<p><code>this is a very important value __str__ = [ 1. 2. 3.]</code></p>\n\n<p>Source: <a href=\"http://deeplearning.net/software/theano/tutorial/debug_faq.html#how-do-i-print-an-intermediate-value-in-a-function\" rel=\"nofollow noreferrer\">Theano 1.0 docs: “How do I Print an Intermediate Value in a Function?”</a></p>\n" } ]

[ { "AnswerId": "17641624", "CreationDate": "2013-07-14T17:07:12.220", "ParentId": null, "OwnerUserId": "506544", "Title": null, "Body": "<p>The file mnist.pkl.gz is probably not in the same directory as the script that you are trying to run.</p>\n\n<p>You would be better off receiving the actual location of the file as a command line parameter to the script and then load the file using that path</p>\n" } ]

[ { "AnswerId": "17679464", "CreationDate": "2013-07-16T14:35:20.347", "ParentId": null, "OwnerUserId": "1648011", "Title": null, "Body": "<p>Implement the operator<br>\nI'm not sure of the contents of the transform struct in this case, but assuming it is:</p>\n\n<pre><code>struct transform { float mat[16]; }\n</code></pre>\n\n<p>Then the implementation can be something like:</p>\n\n<pre><code>std::ostream&amp; operator&lt;&lt; (std::ostream&amp; os, const tf::transform&amp; t)\n{\n os &lt;&lt; t.mat[0];\n for(int i=1;i&lt;16;++i) os &lt;&lt; ',' &lt;&lt; t.mat[i];\n return os;\n}\n</code></pre>\n" } ]

[ { "AnswerId": "17859308", "CreationDate": "2013-07-25T13:23:44.903", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>To change how Theano link to BLAS, you need to use Theano flags[1]. They can be set with an environment variable THEANO_FLAGS or with a configuration file.</p>\n\n<p>How did you told Theano to use atlas? If you just installed the atlas packages, it won't work. You need to install the libatlas-dev pacakge as per this Theano installation instruction for Ubuntu[2]</p>\n\n<p>A last point, we don't recommand atlas, especially for Ubuntu. OpenBLAS is packaged for Unbuntu and is faster. See [2] for detail on how to installed them. You will need to remove atlas before installing openblas, otherwise, there will be conflict.</p>\n\n<p>[1]<a href=\"http://www.deeplearning.net/software/theano/library/config.html#envvar-THEANO_FLAGS\" rel=\"nofollow\">http://www.deeplearning.net/software/theano/library/config.html#envvar-THEANO_FLAGS</a>\n[2]<a href=\"http://www.deeplearning.net/software/theano/install_ubuntu.html#install-ubuntu\" rel=\"nofollow\">http://www.deeplearning.net/software/theano/install_ubuntu.html#install-ubuntu</a></p>\n" } ]

[ { "AnswerId": "18006380", "CreationDate": "2013-08-01T23:32:20.517", "ParentId": null, "OwnerUserId": "1053992", "Title": null, "Body": "<p>Mostly when name starts with uppercase letter then it is class name (unless it is completely upper cased, then it mostly means constant). There is no <code>new</code> operator in Python so this naming pattern is pretty important to distinguish functions from classes (anyway it is general pattern). I don't know Theano, but I suppose that <code>TrainFn1Member</code> is a class that implements <code>__call__</code> method, so you can call it's instance like a function. Search for <code>__call__</code> in <code>TrainFn1Member</code> class definition.</p>\n\n<hr>\n\n<p>UPDATE:</p>\n\n<p>According to your comment, <code>TrainFn1Member</code> is a function (what is pretty strange according to what I said above and what is not my idea ;)). In this case it has to return some <code>callable</code> what means that it returns one of 3 things (I hope I have not missed anything): </p>\n\n<ol>\n<li>function (<code>def</code> or <code>lambda</code>)</li>\n<li>instance of class that implements <code>__call__</code></li>\n<li>method of some object (function bound to some class instance)</li>\n</ol>\n\n<p>As I don't know <code>Theano</code> at all, I can only suggest to search deeper being aware of those above.. (and welcome to Hogwarts ;))</p>\n" } ]

[ { "AnswerId": "18189699", "CreationDate": "2013-08-12T14:32:25.263", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p><code>THEANO_FLAGS</code> is an environment variable and .theanorc is a configuration file. You can use both mechanism to configure Theano. This is described <a href=\"http://deeplearning.net/software/theano/library/config.html\" rel=\"nofollow noreferrer\">here</a>.</p>\n\n<p>I never heard of the .pam_environment file. Also, you shouldn't just override the value of <code>LD_LIBRARY_PATH</code>, but append/prepend to it like this:</p>\n\n<pre><code>LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-5.5/lib64/lib\n</code></pre>\n\n<p>For Theano, if you define <code>CUDA_ROOT</code>, you don't need to modify <code>LD_LIBRARY_PATH</code>, so I would just remove the last line.</p>\n\n<p>Normally, if your shell is bash, people define the env variable <code>CUDA_ROOT</code> in the .bashrc file like this:</p>\n\n<pre><code>export CUDA_ROOT=/usr/local/cuda-5.5/bin\n</code></pre>\n\n<p>The change to .bashrc will only be used if you log out and log it again.</p>\n" }, { "AnswerId": "21170740", "CreationDate": "2014-01-16T19:11:04.887", "ParentId": null, "OwnerUserId": "851699", "Title": null, "Body": "<p>On Linux/OSX:</p>\n\n<p>Edit or create the file <code>~/.theanorc</code>. The file should contain:</p>\n\n<pre><code>[global]\nfloatX = float32\ndevice = gpu0\n\n[nvcc]\nfastmath = True\n\n[cuda]\nroot=/usr/local/cuda-5.5/ \n# On a mac, this will probably be /Developer/NVIDIA/CUDA-5.5/\n</code></pre>\n\n<p>You need to add cuda to the $LD_LIBRARY_PATH variable. If you're running eclipse, you can go to Project properties > Interpreters > Configure and interpreter ... > Environment, and then add an LD_LIBRARY_PATH variable that points to your cuda lib folder (probably /Developer/NVIDIA/CUDA-5.5/lib64)</p>\n\n<p>Now when you import theano it should print a message about finding the gpu. You can run the test code at <a href=\"http://deeplearning.net/software/theano/tutorial/using_gpu.html\">http://deeplearning.net/software/theano/tutorial/using_gpu.html</a> to see if it's using the gpu.</p>\n" } ]

[ { "AnswerId": "18189847", "CreationDate": "2013-08-12T14:38:05.080", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>theano.sparse.csr_matrix is a symbolic variable. It don't contain any data. So if you access its .shape and .data, you also obtain a symbolic variable.</p>\n\n<p>Symbolic variable are used to create a Theano graph that you can compile to a function. So this mean Theano is a compiler. As all compiler, it work in 2 steps:</p>\n\n<ol>\n<li>Create a Theano graph and compile it</li>\n<li>Use the compiled function.</li>\n</ol>\n\n<p>There is a shortcut, you can do this to hide the compilation phase:</p>\n\n<pre><code>a_theano_symbolique_variable.eval().\n</code></pre>\n\n<p>If this need input to evalute the symbolic variable, you can pass it as parameters to eval() like this:</p>\n\n<pre><code>a_theano_symbolique_variable.eval(another_theano_var=the_value_of_the_theano_var)\n</code></pre>\n" } ]

[ { "AnswerId": "19515782", "CreationDate": "2013-10-22T10:50:24.620", "ParentId": null, "OwnerUserId": "667127", "Title": null, "Body": "<p>@Nouiz has pointed out the right way to show the values of both train_set_x and train_set_y. The problem was related to the environment variable \"DYLD_FALLBACK_LIBRARY_PATH\" which was not setup.\nI have a couple of python installations on my mac machine. An installation that was there as part of XCode. Another one which I have installed from python.org and a third installation which I installed from anaconda. Internally only the anaconda' python was able to run native c code for theano. My problem was due to me using the other python installations.\nThe way I fixed this was by editing the some lines in .bash_profile in my home directory. I pointed the default version to be the one I installed with anaconda and also set the environment variable DYLD_FALLBACK_LIBRARY_PATH=\"/Users/Me/anaconda/lib\". This solved the problem and everything works like a charm.</p>\n" }, { "AnswerId": "19495252", "CreationDate": "2013-10-21T12:59:18.563", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>First, <code>train_set_x</code> and <code>train_set_y</code> <em>(before the cast)</em> and <code>train_set</code> are separate copy of the same train set. So I suppose you simplified your example too much, as you say that <code>train_set_x</code> is the input and <code>train_set_y</code> is the corresponding label and this don't make sense with the code.</p>\n\n<p>The answer of you question depend of the contain of <code>mnist.pkl.gz</code>. Where did you get it? From the Deep Learning Tutorial? For my answer, I'll suppose <code>train_set</code> is a 2d numpy <code>ndarray</code>. So that you use a different <code>mnist.pkl.gz</code> file then the one from DLT.</p>\n\n<p>With that supposition, you can call <code>train_set_x.get_value()</code> and this will return a copy of the <code>ndarray</code> in shared variable. If you don't want a copy, you can do <code>train_set_x.get_value(borrow=True)</code> and this will work. If the shared variable is on the GPU, this will copy the data from the GPU to the CPU, but it won't copy the data if it is already on the CPU.</p>\n\n<p><code>train_set_y</code> is a <strong>Theano graph</strong>, not a <strong>Theano shared variable</strong>. So you can't call <code>get_value()</code> on it. You need to compile and run the graph that give <code>train_set_y</code>. If you want to evaluate it only once, you can call <code>train_set_y.eval()</code> as a shortcut to compile and run it as it do not take any input except shared variable.</p>\n\n<p>So you can do this:</p>\n\n<pre><code>for x,y in zip(train_set_x.get_value(), train_set_y.eval()):\n print x, y\n</code></pre>\n" } ]

[ { "AnswerId": "19644730", "CreationDate": "2013-10-28T20:43:04.490", "ParentId": null, "OwnerUserId": "359944", "Title": null, "Body": "<p>Looks like <a href=\"http://deeplearning.net/software/theano/library/tensor/basic.html#tensor.stacklists\" rel=\"nofollow\"><code>stacklist</code></a> might do what you want. </p>\n" } ]

[ { "AnswerId": "24258828", "CreationDate": "2014-06-17T08:13:07.617", "ParentId": null, "OwnerUserId": "3609835", "Title": null, "Body": "<p>I think one possible solution would be to write a custom Theano Op following the instructions at <a href=\"http://deeplearning.net/software/theano/extending/\" rel=\"nofollow\">http://deeplearning.net/software/theano/extending/</a> </p>\n\n<p>I would write a pure Python op without support for gradient computation, in which you would only have to implement the make_node() and perform() methods.</p>\n" }, { "AnswerId": "19734538", "CreationDate": "2013-11-01T20:05:25.737", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>I don't know well PyMC3, but I know well Theano. Theano use symbolic compiler and TensorVariable are such symbolic variable. You need to compile and execute the function to get a value out of it. I don't know where to do this in PyMC3. A fast thing to try that will work if the variable depend only on constant and shared variable is to do this call::</p>\n\n<pre><code>the_tensor_variable.eval()\n</code></pre>\n\n<p>This will compile the function and suppose it don't take any variable input and if it compile, it will run it and return the value.</p>\n" } ]

[ { "AnswerId": "19868858", "CreationDate": "2013-11-08T21:31:53.353", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Use that line:</p>\n\n<pre><code>xbound = BoundedGamma('xbound', alpha=1, beta=2, testval=1)\n</code></pre>\n" } ]

[ { "AnswerId": "20149947", "CreationDate": "2013-11-22T16:38:10.997", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>I see 3 possibilities:</p>\n\n<ul>\n<li>If you know before compiling the Theano function the number of matrix in the tensor3 variable, you could use the split() op or just call det() on all matrix in the tensor3.</li>\n<li>If you don't know the shape, you can make your own op, that will loop over the input and call the numpy fct. See for <a href=\"http://www.deeplearning.net/software/theano/tutorial/extending_theano.html\" rel=\"nofollow\">an example</a> on how to make an op.</li>\n<li>Use scan. It is easy to use it for this case. See <a href=\"https://github.com/nicholas-leonard/Theano/commit/74a6265f15ef332d98e3e55aef0bc3c979682269\" rel=\"nofollow\">this example</a>, just change the call from tensordot to det().</li>\n</ul>\n" } ]

[ { "AnswerId": "20235613", "CreationDate": "2013-11-27T06:41:09.193", "ParentId": null, "OwnerUserId": "2015778", "Title": null, "Body": "<p>This works for me:</p>\n\n<pre><code>import theano.tensor as T\nfrom theano import function\n\nx = T.dmatrix('x')\nlinmax = function([x], T.maximum(x,0))\n</code></pre>\n\n<p>Testing:</p>\n\n<pre><code>linmax([[-1,-2],[3,4]])\n</code></pre>\n\n<p>Outputs:</p>\n\n<pre><code>array([[0.,0.],[3.,4.]])\n</code></pre>\n" }, { "AnswerId": "24887725", "CreationDate": "2014-07-22T12:41:56.670", "ParentId": null, "OwnerUserId": "3760518", "Title": null, "Body": "<p>I have seen this implemented as </p>\n\n<pre><code>s = x*(x&gt;0)\n</code></pre>\n\n<p>several times. Dont know if that's faster than T.maximum()</p>\n" } ]

[ { "AnswerId": "20244704", "CreationDate": "2013-11-27T14:11:09.900", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>theano.function() return a python object that is callable. So you can use it do the the computation you described when it was called.</p>\n\n<p>Theano Ops are part of the symbolic graph that describe the computation that you want. Do not forget that Theano have two step as many other language as C and others. You first need to describe the computation that you want, then compile. In C, you define that computation in text file. In Theano, you describe it with a Theano symbolic graph and that graph include Ops.</p>\n\n<p>Then you compile, with possible gcc for C and with theano.function() in Theano.</p>\n\n<p>So Op is the element op the symbolic graph. It describe the computation done at one point in the graph. This page in Theano tutorial describe the graph in more detail:</p>\n\n<p><a href=\"http://deeplearning.net/software/theano/tutorial/symbolic_graphs.html#theano-graphs\" rel=\"nofollow\">http://deeplearning.net/software/theano/tutorial/symbolic_graphs.html#theano-graphs</a></p>\n\n<p>This page describe how to make an Op in Theano:</p>\n\n<p><a href=\"http://deeplearning.net/software/theano/tutorial/extending_theano.html\" rel=\"nofollow\">http://deeplearning.net/software/theano/tutorial/extending_theano.html</a></p>\n\n<p>You can skip the section for optional part. So you can skip most of that page if you don't plan to make one and just want to understand the usage.</p>\n" } ]

[ { "AnswerId": "20285275", "CreationDate": "2013-11-29T11:56:41.720", "ParentId": null, "OwnerUserId": "1398797", "Title": null, "Body": "<p>You have most of the information you need in the comments of the function.</p>\n\n<p><code>T.log(self.p_y_give_x)</code> returns a numpy matrix.</p>\n\n<p>So the [T.arange(y.shape[0]), y] is a slice of the matrix. Here we are using numpy advanced slicing. See: <a href=\"http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html\" rel=\"nofollow\">http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html</a></p>\n" }, { "AnswerId": "35822682", "CreationDate": "2016-03-06T03:13:59.817", "ParentId": null, "OwnerUserId": "5424661", "Title": null, "Body": "<p>I'm also confused about the matrix slicing here. T.arange(y.shape[0]） is a 1d list. y.shape[0] depends on the size of the mini batch you set. y is a list of labels who has the same dimension as T.arange(y.shape[0]). Therefore, this slicing, according to @William Denman's reference, means: for every row in the matrix of T.log(self.p_y_give_x), we select a column index y(in which y denotes the golden label, who is also been used as index here).</p>\n" } ]

[ { "AnswerId": "53204813", "CreationDate": "2018-11-08T09:27:55.523", "ParentId": null, "OwnerUserId": "5108062", "Title": null, "Body": "<p>Autoencoders/Variational Autoencoders does not learn about sequences, it learns to \"map\" the input data to a latent space which has fewer dimensions. For example if the image is <code>64x64x3</code> you could map that to a <code>32 dim</code> tensor/array.</p>\n\n<p>For learning a sequence of images, you would need to connect the output of the autoencoder encoder part to a RNN (LSTM/GRU) which could learn about the sequence of the encoded frames (consecutive frames in latent space). After that, the output of the RNN could connect to the decoder part of the autoencoder so you could see the reconstructed frames.</p>\n\n<p><a href=\"https://github.com/gaborvecsei/Neural-Network-Dreams\" rel=\"nofollow noreferrer\">Here you can find a GitHub project which tries to encode the video frames and then predict sequences</a></p>\n" } ]

[ { "AnswerId": "20481585", "CreationDate": "2013-12-09T21:52:39.857", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>There is an error in your code when you create values. test_set_x.get_value is a python function. So it should be test_set_x.get_value() as you want the value, not the callable that return it. As theano.shared() receive as input a callable, it create a generic Theano varible that isn't a tensor. So when you try to replace x that is a tensor variable with a generic variable, it raise an error as it is not an allowed replacement.</p>\n\n<p>But even better, you don't need to create a new shared variable, just compile the function like this:</p>\n\n<pre><code> f=theano.function([],classifier.p_y_given_x, \n givens={x:test_set_x},on_unused_input='ignore')\n</code></pre>\n" } ]

[ { "AnswerId": "20570978", "CreationDate": "2013-12-13T16:13:28.727", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>This question was answered on Theano mailing list:</p>\n\n<p><a href=\"https://groups.google.com/forum/#!topic/theano-users/J-l9UmpSG2Y\" rel=\"nofollow\">https://groups.google.com/forum/#!topic/theano-users/J-l9UmpSG2Y</a></p>\n" } ]

[ { "AnswerId": "20602231", "CreationDate": "2013-12-16T01:46:20.903", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>There is 2 behavior of numpy.where(condition, [x ,y]). Theano always support you provide 3 parameter to where(). As said in NumPy doc[1], numpy.where(cond) is equivalent to nonzero().</p>\n\n<p>You can do it like this in Theano:</p>\n\n<pre><code>import theano\nimport numpy as np\nv = np.arange(10)\nvar = theano.tensor.vector()\nout = theano.tensor.eq(var, 2).nonzero()[0]\nprint out.eval({var: v})\n</code></pre>\n\n<p>Check line 5. NumPy nonzero() return a tuple. Theano do the same. There is one vector in that tuple per dimensions in the input of nonzero().</p>\n\n<p>[1] <a href=\"http://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html\" rel=\"noreferrer\">http://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html</a></p>\n" } ]

[ { "AnswerId": "21121992", "CreationDate": "2014-01-14T19:14:33.227", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Currently this isn't possible. There is user that modified Theano to allow pickling the Theano function, but during unpickling we already re optimize the graph.</p>\n\n<p>There is a Pull Request that allow Theano to generate a C++ library. The user can then compile it himself and use it as a normal C++ library. The lib links against the python lib and requires numpy to be installed. But this isn't ready for broad usage.</p>\n\n<p>What is your goal? To save on the compilation time? If so Theano already caches the c++ module that it compiles, so the next time it is reused, the compilation will be faster. But for a big graph, the optimization phase is always redone as told above, and this can take a significant time.</p>\n\n<p>So what is your goal?</p>\n\n<p>This is something that we are working on. Make sure to use the latest Theano release (0.6) as it compiles faster. The development version is also a little faster.</p>\n" } ]

[ { "AnswerId": "21320362", "CreationDate": "2014-01-23T22:08:51.633", "ParentId": null, "OwnerUserId": "425797", "Title": null, "Body": "<p>If you have code running in Numpy, translating it to Theano is not going to make it magically faster, and it's going to take a significant coding effort.</p>\n\n<p>Theano is really nice, but choosing it is more of a design-time decision - you wanna have all the niceties of symbolic differentiation so you don't have to calculate your gradients by hand for backpropr, so you use that framework. </p>\n\n<p>If you already have the Numpy code ready, just optimize the bottleneck, which in your case must be that dot product. I would try using the dot function instead of einsum, i.e. instead of:</p>\n\n<pre><code>dw = np.einsum('ij,ik-&gt;jk', layerValues[layer - 1], deDz)\n</code></pre>\n\n<p>Try:</p>\n\n<pre><code>dw = layerValues[layer-1].T.dot(deDz)\n</code></pre>\n\n<p>Sometimes einsum is dumb so that might be faster. If not, consider either </p>\n\n<ol>\n<li>using the GPU for the matrix-vector multiplication, via gnumpy <em>or</em></li>\n<li>using a better algorithm that'll converge faster than plain old gradient descent (which I assume is what you're using): adagrad or a second-order optimization algorithm - lbfgs, say - </li>\n</ol>\n" }, { "AnswerId": "21323254", "CreationDate": "2014-01-24T02:24:03.667", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>You don't need to change all your script to use Theano. You can re implement just part of your code with Theano and it will work. Theano take numpy ndarray as input and return numpy ndarray as output by default. So the integration is easy with numpy.</p>\n\n<p>Theano don't implement einsum. So I would recommend you to start by replacing that with call to dot as Patrick said. I have see and hear many times that einsum is slower then call to dot in some cases. If that speed up isn't good enough, Theano can help you. If you just move the dot call to Theano, Theano won't be faster if Theano and NumPy are linked to the same BLAS library. But Theano should make you code faster if you move more computation to it. But it isn't perferct and some case don't have speed up and rare cases have slowdown compared to NumPy(mostly when the input shapes aren't big enough like with scalar) </p>\n\n<p>About Patrick answer, you don't need to use the symbolic gradient of Theano to benefit from Theano. But if you want to use the symbolic gradient, Theano can only compute the symbolic gradient inside computation graph done in Theano. So you will need to convert that part completely to Theano. But as your code already work, it mean you have manually implement the grad. This is fine and don't cause any problem. You can move that manual implementation of the grad to Theano without using the symbolic gradient.</p>\n\n<p>About Patrick comment on GPU. Don't forget that the transfer CPU/GPU of data is the most costly operation on the GPU. It can completely cancel the GPU speed up in many cases. So it isn't sure that doing only the dot on the GPU will help. In Theano, we put the weight on the GPU and without doing that I don't think you can get speed up from the GPU (which ever gnumpy/Theano/something else). The cases when doing only the DOT on the GPU will still give speed up is with gigantic matrices.</p>\n" } ]

[ { "AnswerId": "54492982", "CreationDate": "2019-02-02T12:13:35.980", "ParentId": null, "OwnerUserId": "1744914", "Title": null, "Body": "<p>In case you are using <a href=\"https://github.com/pyenv/pyenv\" rel=\"nofollow noreferrer\">pyenv</a> you can do that with</p>\n\n<pre><code>CONFIGURE_OPTS=--enable-shared pyenv install 3.6.5\n</code></pre>\n" }, { "AnswerId": "21345831", "CreationDate": "2014-01-25T02:25:28.387", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>You didn't build correctly python. It wasn't compiled with the -fPIC parameter. Look at how to compile python with a shared library.</p>\n\n<p>EDIT:\nYou need to compile python like this:</p>\n\n<pre><code>./configure --enable-shared\nmake\nmake install\n</code></pre>\n" }, { "AnswerId": "44847761", "CreationDate": "2017-06-30T13:32:29.110", "ParentId": null, "OwnerUserId": "8047453", "Title": null, "Body": "<p>I used a virtualenv on Ubuntu 16.04, and before installing python with <code>pyenv install 3.6.1</code> I ran the following command to ensure python is built with the fPIC flag:</p>\n\n<pre><code>export CONFIGURE_OPTS=\"OPT=\\\"-fPIC\\\"\"\n</code></pre>\n\n<p>Then I was able to install and run theano properly.</p>\n" } ]

[ { "AnswerId": "21483126", "CreationDate": "2014-01-31T15:01:28.823", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The function \"get_reconstructed_input\" will return a Theano variable that represent z from the hidden representation. Check the function \"get_cost_updates\" It use it to train the model.</p>\n\n<pre><code> tilde_x = self.get_corrupted_input(self.x, corruption_level)\n y = self.get_hidden_values( tilde_x)\n z = self.get_reconstructed_input(y)\n</code></pre>\n\n<p>If you don't want to train the model, you can do this:</p>\n\n<pre><code> y = self.get_hidden_values(self.x)\n z = self.get_reconstructed_input(y)\n</code></pre>\n\n<p>To make an executable function that compute this:</p>\n\n<pre><code>f = theano.function([x], z)\n</code></pre>\n" } ]

[ { "AnswerId": "21703319", "CreationDate": "2014-02-11T13:32:15.160", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Theano does not create any configuration file by itself, but has default values for all its configuration flags. You only need such a file if you want to modify the default values.</p>\n\n<p>This can be done by creating a .theanorc file in your home directory. For example, if you want floatX to be always float32, you can do this:</p>\n\n<pre><code>echo -e \"\\n[global]\\nfloatX=float32\\n\" &gt;&gt; ~/.theanorc\n</code></pre>\n\n<p>under Linux and Mac. Under windows, this can also be done. See this page for more details:</p>\n\n<p><a href=\"http://deeplearning.net/software/theano/library/config.html\" rel=\"noreferrer\">http://deeplearning.net/software/theano/library/config.html</a></p>\n" }, { "AnswerId": "39484318", "CreationDate": "2016-09-14T07:02:45.287", "ParentId": null, "OwnerUserId": "6713172", "Title": null, "Body": "<p>I had a similar question and this is what helped me:</p>\n\n<pre><code>import theano\n//...\ntheano.config.floatX = 'float32' //or 'float64' whatever you want\n</code></pre>\n" }, { "AnswerId": "47619039", "CreationDate": "2017-12-03T13:47:55.660", "ParentId": null, "OwnerUserId": "4494896", "Title": null, "Body": "<p>I have been having similar problems. I have NVIDIA 1070 GPU on a desktop machine with Asus Z270E motherboard and was able to import theano after setting up the .theanorc file as below. (And rebooting afterwards)</p>\n\n<pre><code>[global]\nfloatX = float32\ndevice = gpu\n\n[cuda]\nroot = /usr/local/cuda\n[lib]\ncnmem = 1 \n</code></pre>\n" }, { "AnswerId": "44446622", "CreationDate": "2017-06-08T22:36:05.993", "ParentId": null, "OwnerUserId": "1673784", "Title": null, "Body": "<p>This worked for me:</p>\n\n<pre><code>nano ~/.theanorc\n</code></pre>\n\n<p>Then I entered:</p>\n\n<pre><code>[global]\nfloatX = float32\ndevice = cuda\n</code></pre>\n\n<p>Code to check if Theano is using the GPU is on the <a href=\"http://deeplearning.net/software/theano/tutorial/using_gpu.html\" rel=\"nofollow noreferrer\">Theano doc page</a>.</p>\n\n<p>(I am using Ubuntu 14.04, Theano 0.9.0 (conda), NVIDIA 1080 Ti GPU).</p>\n" }, { "AnswerId": "40015751", "CreationDate": "2016-10-13T08:19:01.857", "ParentId": null, "OwnerUserId": "4755098", "Title": null, "Body": "<p>In Linux in terminal Home directory write:</p>\n\n<pre><code>nano .theanorc\n</code></pre>\n\n<p>In the file copy the following lines</p>\n\n<pre><code>[global]\nfloatX = float32\ndevice = gpu0\n\n[lib]\ncnmem = 1 \n</code></pre>\n\n<p>Save it.</p>\n\n<p>When I import theano in python I was having cnmem memory problems. Seems that is because the monitor is connected to the gpu. To resolve it change cnmem to 0.8. This number below 1 is the percentage of gpu reserved for theano</p>\n" } ]

[ { "AnswerId": "21703090", "CreationDate": "2014-02-11T13:23:03.837", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Your python installation is incomplete. When you do:</p>\n\n<pre><code>module load libs/python/2.7.3\n</code></pre>\n\n<p>information is added to your environment variables to make you use python 2.7.3. But this version doesn't include the development header of python (Theano needs this). Or it doesn't put the right path in your environment.</p>\n\n<p>To debug this, run this before and after running \"module load libs/python/2.7.3\" to compare what module load does:</p>\n\n<pre><code>env &amp;&gt; BEFORE.txt\nmodule load libs/python/2.7.3\nenv &amp;&gt; AFTER.txt\ndiff BEFORE.txt AFTER.txt\n</code></pre>\n\n<p>Then check the paths added to your env variables and look in those directories. It should have modified the LD_LIBRARY_PATH variable, but it should have done the same modification to LIBRARY_PATH. If it doesn't, do that modification yourself and tell your system admin about this.</p>\n\n<p>This will solve your problem.</p>\n\n<p>Otherwise, use the python 2.6 from the OS, maybe in include the development version.</p>\n\n<p>Otherwise, check if other python versions are available via module.</p>\n\n<p>Lastly, contact your system admin to add the development and shared version of python or install it yourself:</p>\n\n<pre><code>wget -c http://www.python.org/ftp/python/2.7.6/Python-2.7.6.tgz\ntar -jxf Python-2.7.6.tar.bz2 \ncd Python-2.7.6\n./configure --prefix=~/python2.7.6 --enable-shared\nmake\nmake install\n</code></pre>\n" } ]

[ { "AnswerId": "21714067", "CreationDate": "2014-02-11T22:04:06.240", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The development version of Theano don't need changes to DYLD_FALLBACK_LIBRARY_PATH. So undo the change to it and update your Theano version. From:</p>\n\n<p><a href=\"http://www.deeplearning.net/software/theano/install.html#bleeding-edge-install-instructions\">http://www.deeplearning.net/software/theano/install.html#bleeding-edge-install-instructions</a></p>\n\n<p>Run one of those 2 command depending of your need:</p>\n\n<pre><code>pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git --install-option='--prefix=~/.local'\npip install --upgrade --no-deps git+git://github.com/Theano/Theano.git\n</code></pre>\n\n<p>EDIT: I removed the link to an answer elsewhere and copied the answer here. Thanks</p>\n" } ]

[]

[ { "AnswerId": "26458679", "CreationDate": "2014-10-20T04:42:00.403", "ParentId": null, "OwnerUserId": "2440487", "Title": null, "Body": "<p>Microsoft Research has released a toolkit for language modelling with word2vec-style vectors. You can find it <a href=\"http://research.microsoft.com/en-us/projects/rnn/\" rel=\"noreferrer\">here</a>.</p>\n" }, { "AnswerId": "22037003", "CreationDate": "2014-02-26T09:27:12.083", "ParentId": null, "OwnerUserId": "3153644", "Title": null, "Body": "<p><code>word2vec</code> is a tool to represent a single word (o a group of words) as a numerical vector. So it is not directly related to a language model.</p>\n\n<p>To generate a Language model you can use the <a href=\"https://code.google.com/p/mitlm/\" rel=\"nofollow\">MITLM</a> to do it. For example you can create a N-gram model using the corpus <code>Lectures.txt</code> with this command:</p>\n\n<pre><code>estimate-ngram -text Lectures.txt -write-lm Lectures.lm\n</code></pre>\n\n<p>A great tutorial can be found <a href=\"http://projects.csail.mit.edu/cgi-bin/wiki/view/SLS/MITLMTutorial\" rel=\"nofollow\">here</a>.</p>\n" }, { "AnswerId": "34802772", "CreationDate": "2016-01-15T01:12:05.107", "ParentId": null, "OwnerUserId": "956730", "Title": null, "Body": "<p>Doc2Vec implemented in Gensim does the job. The trick is that they use the document ID as a context word, which is present in all window sizes of all the words in the document.</p>\n\n<p>Code is <a href=\"https://radimrehurek.com/gensim/models/doc2vec.html\" rel=\"nofollow\">here in Python/Gensim</a></p>\n" } ]

[ { "AnswerId": "22352914", "CreationDate": "2014-03-12T13:23:40.827", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>How did you install numpy/scipy/mingw? I think they are installed by default with canopy. As you tried many things, I would suggest that you remove all other python installation and only keep canopy. Canopy provide blas, so you don't need to install one. It is better to install the academic/full version of canopy as it provide a faster BLAS. Their should be newer version of mingw and libpython in canopy since the instruction was done. Install them.</p>\n\n<p>Then this is done, you only need to install theano with this command:</p>\n\n<pre><code>pip install --upgrade --no-deps Theano\n</code></pre>\n\n<p>All the command you provides are different way to install Theano. You only need one! If you want the development version, you can use this instead:</p>\n\n<pre><code>git clone git://github.com/Theano/Theano.git\ncd Theano\npython setup.py develop\n</code></pre>\n" } ]

[ { "AnswerId": "24844120", "CreationDate": "2014-07-19T19:23:07.013", "ParentId": null, "OwnerUserId": "1714410", "Title": null, "Body": "<p>You need to define <code>y</code> as <code>T.imatrix()</code> instead of <code>T.lvector()</code>.</p>\n" } ]

[ { "AnswerId": "22612374", "CreationDate": "2014-03-24T14:33:38.670", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>You can get the value of a shared variable like this:</p>\n\n<pre><code>w.get_value()\n</code></pre>\n\n<p>Then this would work:</p>\n\n<pre><code>w.get_value().shape\n</code></pre>\n\n<p>But this will copy the shared variable content. To remove the copy you can use the borrow parameter like this:</p>\n\n<pre><code>w.get_value(borrow=True).shape\n</code></pre>\n\n<p>But if the shared variable is on the GPU, this will still copy the data from the GPU to the CPU. To don't do this:</p>\n\n<pre><code>w.get_value(borrow=True, return_internal_type=True).shape\n</code></pre>\n\n<p>Their is a simpler way to do this, compile a Theano function that return the shape:</p>\n\n<pre><code>w.shape.eval()\n</code></pre>\n\n<p><code>w.shape</code> return a symbolic variable. .eval() will compile a Theano function and return the value of shape.</p>\n\n<p>If you want to know more about how Theano handle the memory, check this web page: <a href=\"http://www.deeplearning.net/software/theano/tutorial/aliasing.html\">http://www.deeplearning.net/software/theano/tutorial/aliasing.html</a></p>\n" } ]

[ { "AnswerId": "22787775", "CreationDate": "2014-04-01T13:43:32.170", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>This ticket was closed as off-topick, so I answered it in the comment. So here my answer as a post.</p>\n\n<p>My answer is generic and apply to all system, not just Theano. As each iteration of your loop depend on the previous one, you can't paralelize your iterations completly. You could parallelize the <code>u=data[t]</code> as it don't depend on the previous x. You could parallelize <code>dot( Win, vstack((1,u)) )</code> for the same reason. But you can't parallelize <code>dot(W,x)</code> and what depend on it like tanh and the lines afters.</p>\n\n<p>If you want to optimize this, you can move outside the loop all computation that don't depend on x. This will allow to work with more data at the same time and so could be faster. So the <code>dot(win, ...)</code> could be speed up. But this will raise the memory usage.</p>\n" } ]

[ { "AnswerId": "33166614", "CreationDate": "2015-10-16T09:13:11.607", "ParentId": null, "OwnerUserId": "5453108", "Title": null, "Body": "<p>I had same problem. I think this problem is because of Overshooting.\nSo I decreased learning rate 0.1 to 0.013 and increase epoch.\nThen it works. \nBut I'm not sure your problem is same.</p>\n" }, { "AnswerId": "22682341", "CreationDate": "2014-03-27T08:46:24.453", "ParentId": null, "OwnerUserId": "956730", "Title": null, "Body": "<p>I asked the same question in Theano's user groups and they answered that feature values should be between 0 and 1.</p>\n\n<p>So i used a normalizer to normalize feature values and it solved the problem.</p>\n" } ]

[ { "AnswerId": "22701190", "CreationDate": "2014-03-27T23:16:05.883", "ParentId": null, "OwnerUserId": "2317533", "Title": null, "Body": "<p>Is Eclipse using the same version of python as what you are running in the shell (console)? Does Eclipse know where to find theano- does it have a PYTHONPATH setting for it?</p>\n\n<p>What OS are you using?</p>\n" }, { "AnswerId": "22793080", "CreationDate": "2014-04-01T17:43:38.147", "ParentId": null, "OwnerUserId": "1568741", "Title": null, "Body": "<p>ok, I found the answer finally. I never really had an error. I did not find that out because I never tried to actually run the script because the editor indicated there was an error... The maker of PyDev answered the following question himself and provides a workaround:</p>\n\n<p><a href=\"https://stackoverflow.com/questions/2112715/how-do-i-fix-pydev-undefined-variable-from-import-errors\">How do I fix PyDev &quot;Undefined variable from import&quot; errors?</a></p>\n\n<p>For code in your project, the only way is adding a comment saying that you expected that (the static code-analysis only sees what you see, not runtime info -- if you opened that module yourself, you'd have no indication that main was expected).</p>\n\n<p>You can use ctrl+1 (Cmd+1 for Mac) in a line with an error and pydev will present you an option to add a comment to ignore that error.</p>\n" } ]

[ { "AnswerId": "22774654", "CreationDate": "2014-04-01T00:27:01.520", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>First, pkl aren't great to save binary data and aren't memory friendly. It must copy all the data in ram before writing to disk. So this double the memory usage! You can use numpy.save and numpy.load to stores ndarray without that memory doubling.</p>\n\n<p>For the Theano variable, I guess you are using a Theano shared variable. By default, when you get it via <code>get_value()</code>, it copy the data. You can use <code>get_value(borrow=True)</code> to don't copy this.</p>\n\n<p>Both of those change together could lower the memory usage by 3x. If this isn't enough or if you are sick of handling multiple files yourself, I would suggest that you use pytables: <a href=\"http://www.pytables.org/\" rel=\"nofollow\">http://www.pytables.org/</a> It allow to have one big ndarray stored in a file bigger then the ram avaiable, but it give an object similar to ndarray that you can manipulate very similarly to an ndarray.</p>\n" } ]

[ { "AnswerId": "22803664", "CreationDate": "2014-04-02T06:54:31.207", "ParentId": null, "OwnerUserId": "359944", "Title": null, "Body": "<p>This will be somewhat easier in PyMC 2.3, so installing 2.3 is a pretty good option.</p>\n\n<p>In PyMC 3 that doesn't work because cx, cy, and rho are theano TensorVariables and mvncdf expects numpy arrays. Theano variables are not a kind of numpy array. Instead they <em>represent</em> a computation leading to a numpy array. </p>\n\n<p>You'll need to make mvncdf into a Theano operator (theano analog of a numpy function). There unfortunately isn't a super simple way to do that right now, though <a href=\"https://github.com/Theano/Theano/issues/1784\" rel=\"nofollow\">it is coming</a>. You can also take a look at the <a href=\"http://deeplearning.net/software/theano/tutorial/extending_theano.html\" rel=\"nofollow\">guide to making a Theano Op</a>.</p>\n" } ]

[ { "AnswerId": "31435097", "CreationDate": "2015-07-15T15:46:09.383", "ParentId": null, "OwnerUserId": "5116849", "Title": null, "Body": "<p>Other than the point raised by nouiz, P should not be declared as a T.vector because it will be the result of computation on your vector of values.</p>\n\n<p>Also, to compute something like entropy, you do not need to use Scan (Scan introduces a computation overhead so it should only be used because there's no other way of computing what you want or to reduce memory usage); you can take a approach like this :</p>\n\n<pre><code>values = T.vector('values')\nnb_values = values.shape[0]\n\n# For every element in 'values', obtain the total number of times\n# its value occurs in 'values'.\n# NOTE : I've done the broadcasting a bit more explicitly than\n# needed, for clarity.\nfreqs = T.eq(values[:,None], values[None, :]).sum(0).astype(\"float32\")\n\n# Compute a vector containing, for every value in 'values', the\n# probability of that value in the vector 'values'.\n# NOTE : these probabilities do *not* sum to 1 because they do not\n# correspond to the probability of every element in the vector 'values\n# but to the probability of every value in 'values'. For instance, if\n# 'values' is [1, 1, 0] then 'probs' will be [2/3, 2/3, 1/3] because the\n# value 1 has probability 2/3 and the value 0 has probability 1/3 in\n# values'.\nprobs = freqs / nb_values\n\nentropy = -T.sum(T.log2(probs) / nb_values)\nfct = theano.function([values], entropy)\n\n# Will output 0.918296...\nprint fct([0, 1, 1])\n</code></pre>\n" } ]

[ { "AnswerId": "22883792", "CreationDate": "2014-04-05T16:48:54.983", "ParentId": null, "OwnerUserId": "102441", "Title": null, "Body": "<p><code>theano.tensor</code> calculates the <em>elementwise</em> inverse</p>\n\n<p><code>np.linalg.inv</code> calculates the inverse <em>matrix</em></p>\n\n<p>These are not the same thing mathematically</p>\n\n<hr>\n\n<p>You're probably looking for the <strong>experimental</strong> <a href=\"http://deeplearning.net/software/theano/library/sandbox/linalg.html#theano.sandbox.linalg.ops.MatrixInverse\" rel=\"nofollow\"><code>theano.sandbox.linalg.ops.MatrixInverse</code></a></p>\n" } ]

[ { "AnswerId": "27993778", "CreationDate": "2015-01-16T22:25:59.767", "ParentId": null, "OwnerUserId": "1639345", "Title": null, "Body": "<p>I had a similar error and was able to resolve it by adding a <code>.theanorc</code> file containing the following two lines:</p>\n\n<pre><code>[global]\n\nfloatX = float32\n</code></pre>\n\n<p>That seemed to fix everything. However, your problem shows a slightly different error. But I think it's worth trying.</p>\n" }, { "AnswerId": "22914819", "CreationDate": "2014-04-07T14:07:50.993", "ParentId": null, "OwnerUserId": "1590306", "Title": null, "Body": "<p>Error looks quite self-explanatory; have you tried:</p>\n\n<pre><code>dt = np.dtype(np.float32) \n</code></pre>\n\n<p>??</p>\n" }, { "AnswerId": "22930872", "CreationDate": "2014-04-08T07:53:35.570", "ParentId": null, "OwnerUserId": "643014", "Title": null, "Body": "<p>This answer comes from <a href=\"https://groups.google.com/forum/#!topic/theano-users/ofTRZJz7oZQ\" rel=\"nofollow noreferrer\">Theano-users google group</a>.</p>\n\n<p>You define your <code>x</code> variable as:</p>\n\n<pre><code>x=T.vector(dtype=theano.config.floatX)\n</code></pre>\n\n<p>This is it is a vector(i.e. it only have 1 dimensions).</p>\n\n<pre><code>x_inp = np.matrix('2;1',dtype=dt)\n</code></pre>\n\n<p>create a matrix, not a vector.</p>\n\n<p>Theano graph are strongly typed, you must defined the good number of\ndimensions. Just use:</p>\n\n<pre><code>x_inp = np.asarray([2,1]) \n</code></pre>\n\n<hr>\n\n<p>I actually ended up defining <code>x</code> and <code>b</code> as matrices.</p>\n" } ]

[ { "AnswerId": "23314906", "CreationDate": "2014-04-26T18:26:33.160", "ParentId": null, "OwnerUserId": "773960", "Title": null, "Body": "<p>There is a good breakdown of different physics/math ways to think of tensor in Jim Belk's <a href=\"https://math.stackexchange.com/a/192441\">answer</a> to a question on math.stackexchange. After looking over the <a href=\"http://deeplearning.net/software/theano/library/tensor/index.html\" rel=\"nofollow noreferrer\">documentation</a> on tensor and the various operations Theano provides I'd say Theano's notion of tensor corresponds to the first way of thinking of tensor. In Jim's words:</p>\n\n<blockquote>\n <p>Tensors are sometimes defined as multidimensional arrays, in the same way that a matrix is a two-dimensional array. From this point of view, a matrix is certainly a special case of a tensor.</p>\n</blockquote>\n\n<p>In any case, I don't see anything myself in the docs indicating that Theano's tensor implementation knows about global properties of manifolds or tensor products in linear algebra beyond defining dot-products and the like. This would indicate Theano is taking a local point of view in it's implementation as opposed to the global.</p>\n" } ]

[ { "AnswerId": "23635590", "CreationDate": "2014-05-13T15:33:08.417", "ParentId": null, "OwnerUserId": "1461210", "Title": null, "Body": "<p>You are trying to pass <code>a.z</code> to <code>a.ac()</code>, whereas <code>a.z</code> is actually the <em>result</em> of <code>a.ac(x)</code>!</p>\n\n<p>Instead, you probably want do this:</p>\n\n<pre><code>a.ac(a.inputs)\n# array([ 8.61379147, -13.0183053 , -4.41056323])\n</code></pre>\n\n<p>The value of the symbolic variable <code>a.z</code> is undetermined until <code>a.x</code>, <code>a.W</code> and <code>a.b</code> can all be evaluated. The syntax for <a href=\"http://deeplearning.net/software/theano/library/compile/function.html\" rel=\"nofollow\"><code>theano.function</code></a> works like this:</p>\n\n<pre><code>find_x = theano.function([&lt;inputs needed to compute x&gt;], &lt;output x&gt;)\n</code></pre>\n\n<p>When you actually want to call <code>find_x()</code>, you only need to give it the stuff in the square brackets, and the second argument to <code>theano.function</code> will be the return value of <code>find_x()</code>.</p>\n" } ]

[ { "AnswerId": "23660792", "CreationDate": "2014-05-14T16:58:56.603", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Theano \"tensor\" variable are symbolic variable. What you build with them are like a programme that you write. You need to compile a Theano function to execute what this program do. There is 2 ways to compile a Theano function:</p>\n\n<pre><code>f = theano.function([testxx.input], [outxx])\nf_a1 = f(a)\n\n# Or the combined computation/execution\nf_a2 = outxx.eval({testxx.input: a})\n</code></pre>\n\n<p>When you compile a Theano function, your must tell what the input are and what the output are. That is why there is 2 parameter in the call to theano.function(). eval() is a interface that will compile and execute a Theano function on a given symbolic inputs with corresponding values.</p>\n" }, { "AnswerId": "31883372", "CreationDate": "2015-08-07T17:22:07.730", "ParentId": null, "OwnerUserId": "3497273", "Title": null, "Body": "<p>Since <code>testxx</code> uses <code>sum()</code> from <code>theano.tensor</code> and not from <code>numpy</code>, it probably expects a <code>TensorVariable</code> as input, and not a numpy array.</p>\n\n<p>=> Replace <code>a = np.array(...)</code> with <code>a = T.matrix(dtype=theano.config.floatX)</code>.</p>\n\n<p>Before your last line, <code>outxx</code> will then be a <code>TensorVariable</code> that depends on <code>a</code>. So you can evaluate it by giving the value of <code>a</code>.</p>\n\n<p>=> Replace your last line <code>outxx = np.asarray(...)</code> with the following two lines.</p>\n\n<pre><code>f = theano.function([a], outxx)\noutxx = f(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype = np.float32))\n</code></pre>\n\n<p>The following code runs without errors.</p>\n\n<pre><code>import theano\nimport theano.tensor as T\nimport numpy as np\n\nclass testxx(object):\n def __init__(self, input):\n self.input = input\n self.output = T.sum(input)\na = T.matrix(dtype=theano.config.floatX)\nclassfier = testxx(a)\noutxx = classfier.output\nf = theano.function([a], outxx)\noutxx = f(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype = np.float32))\n</code></pre>\n\n<p>Theano documentation on <a href=\"http://deeplearning.net/software/theano/tutorial/adding.html\" rel=\"nofollow\">adding scalars</a> gives other similar examples.</p>\n" } ]

[ { "AnswerId": "23661302", "CreationDate": "2014-05-14T17:29:04.027", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The problem is that you override the l.x in the second loop. You can't do that. Once self.x is used in the <strong>init</strong>, the result based on it are based on the current instance of self.x. So when you override it, it don't recreate the other stuff on the new x.</p>\n\n<p>You should pass x as in input to <strong>init</strong>. If None, create one. This is for the first layer. For the other, it should be the previous layer output.</p>\n\n<pre><code>def __init__(self, n_in, n_out, x=None):\n if x is not None:\n self.x = x\n else:\n x = T.dvector('x')\n</code></pre>\n" } ]

[ { "AnswerId": "23996593", "CreationDate": "2014-06-02T14:10:47.983", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The problem is this: <code>train_set[index]</code></p>\n\n<p>Here train_set is a numpy ndarray and index a Theano variable. NumPy don't know how to work with Theano variables. You must convert train_set to a Theano variable like a shared variable:</p>\n\n<pre><code>train_set = theano.shared(train_set)\n</code></pre>\n\n<p>You also need to change your declaration of index as Theano don't support real value for index:</p>\n\n<pre><code>index = T.iscalar()\n</code></pre>\n" } ]

[ { "AnswerId": "23765727", "CreationDate": "2014-05-20T16:53:55.277", "ParentId": null, "OwnerUserId": "1724013", "Title": null, "Body": "<p>I think you need to be a little more specific. When you say \"I am unable to figure to how exactly the summary is generated for each document\", do you mean that you don't know how to <em>interpret</em> the learned features, or don't you understand the algorithm? Also, \"deep learning techniques\" covers a very broad range of models - which one are you actually trying to use?</p>\n\n<p>In the general case, deep learning models do not learn features that are humanly intepretable (albeit, you can of course try to look for correlations between the given inputs and the corresponding activations in the model). So, if that's what you're asking, there really is no good answer. If you're having difficulties understanding the model you're using, I can probably help you :-) Let me know. </p>\n" } ]

[ { "AnswerId": "23819788", "CreationDate": "2014-05-23T01:47:43.927", "ParentId": null, "OwnerUserId": "534969", "Title": null, "Body": "<p>The logistic regression class used as output layer in the MLP tutorial is not the \"standard\" logistic regression, which gives as output a single value and discriminates between just two classes, but rather a Multinomial Logistic Regression (a.k.a Softmax Regression), which gives as output one value for each class, telling the probability of the input belonging to them. So, if you have 10 classes, you'll also need 10 units and obviously the sum of all output units equals 1, since it's a probability distribution.</p>\n\n<p>Despite of the class name used (\"LogistRegression\"), its doctring in the <a href=\"http://deeplearning.net/tutorial/code/logistic_sgd.py\" rel=\"nofollow\">linked source code</a> leaves no doubts of its real intent (<code>'''Multi-class Logistic Regression Class [...]'''</code>).</p>\n\n<p>Whereas in your problem you have two classes, you'll also need 2 output units and the value for your <code>n_out</code> must be 2 instead of 1. Of course, with two classes the value for one output will be always 1 minus the value of the other.</p>\n\n<p>Also, check if you really need int64 instead of int32. Theano has much better support for the second.</p>\n" } ]

[ { "AnswerId": "23789646", "CreationDate": "2014-05-21T17:05:01.477", "ParentId": null, "OwnerUserId": "534969", "Title": null, "Body": "<p>This sections of the convnet tutorial has a bug or is very outdated. Symbolic variables in Theano are located in theano.tensor package. This package theano.floatX even doesn't exist!</p>\n\n<p>The current version in the tutorial github repository works fine. They allocate the symbolic variable the right way:</p>\n\n<pre><code># allocate symbolic variables for the data\n index = T.lscalar() # index to a [mini]batch\n x = T.matrix('x') # the data is presented as rasterized images\n y = T.ivector('y') # the labels are presented as 1D vector of\n # [int] labels\n</code></pre>\n\n<p>Browsing the tutorial repository I found the <a href=\"https://github.com/lisa-lab/DeepLearningTutorials/commit/21065c8271913be6667357cbd3df5d37bba144d1\" rel=\"nofollow\">revision where this bug was corrected</a>. \nThey seem to have forgotten to update the tutorial text with this fix.</p>\n" } ]

[ { "AnswerId": "23797179", "CreationDate": "2014-05-22T03:05:50.957", "ParentId": null, "OwnerUserId": "2014584", "Title": null, "Body": "<p>The <code>max</code> and <code>exp</code> operations are fundamentally different; <code>exp</code> (and other operations like addition, <code>sin</code>, etc.) is an elementwise operation that is embarrassingly parallelizable, while <code>max</code> requires a parallel-processing scan algorithm that basically builds up a tree of pairwise comparisons over an array. It's not impossible to speed up <code>max</code>, but it's not as easy as <code>exp</code>.</p>\n\n<p>Anyway, the <code>theano</code> implementation of <code>max</code> basically consists of the following lines (in theano/tensor/basic.py):</p>\n\n<pre><code>try:\n out = max_and_argmax(x, axis)[0]\nexcept Exception:\n out = CAReduce(scal.maximum, axis)(x)\n</code></pre>\n\n<p>where <code>max_and_argmax</code> is a bunch of custom code that, to my eye, implements a max+argmax operation using <code>numpy</code>, and <code>CAReduce</code> is a generic GPU-accelerated scan operation used as a fallback (which, according to the comments, doesn't support <code>grad</code> etc.). You could try using the fallback directly and see whether that is faster, maybe something like this:</p>\n\n<pre><code>from theano.tensor.elemwise import CAReduce\nfrom theano.scalar import maximum\n\ndef mymax(X, axis=None):\n CAReduce(maximum, axis)(X)\n</code></pre>\n" }, { "AnswerId": "23811048", "CreationDate": "2014-05-22T15:24:39.330", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The previous answer is partial. The suggestion should not work, as the work around is the one used in the final compiled code. There is optimization that will do this transformation automatically.</p>\n\n<p>The title of the question isn't the same as the content. They differ by the axis argument. I'll answer both questions.</p>\n\n<p>If the axis is 0 or None we support this on the GPU for that operation for matrix. If the axis is None, we have a basic implementation that isn't well optimized as it is harder to parallelize. If the axis is 0, we have a basic implementation, but it is faster as it is easier to parallelize.</p>\n\n<p>Also, how did you do your timing? If you just make one function with only that operation and test it via the device=gpu flags to do your comparison, this will include the transfer time between CPU and GPU. This is a memory bound operation, so if you include the transfer in your timming, personnaly I don't expect any speed op for that case. To see only the GPU operation, use Theano profiler: run with the Theano flag profile=True.</p>\n" } ]

[ { "AnswerId": "23978780", "CreationDate": "2014-06-01T10:14:47.000", "ParentId": null, "OwnerUserId": "3489247", "Title": null, "Body": "<p>The docstring of <code>conv2d</code> says <em>signal.conv.conv2d performs a basic 2D convolution of the input with the\ngiven <strong>filters</strong>.</em> (note the plural)</p>\n\n<p>You could pass it <strong>several</strong> filters and it will return the convolutions with all of those. Try e.g.</p>\n\n<pre><code>c = conv2d(m,np.array([w, w, w]))\nf = theano.function([m], c)\nprint f(numpy.ones([100,100], dtype=numpy.float32)).shape # outputs (3, 91, 100)\n</code></pre>\n\n<p>So it seems that by default it will add a degenerate axis if you only pass 1 filter (probably because it adds this axis internally to your filter if you didn't pass it in that way yourself. In other words, it doesn't keep track of the input shape in order to return something that corresponds. Looks like a design choice more than anything else.)</p>\n" } ]

[ { "AnswerId": "24187030", "CreationDate": "2014-06-12T14:31:15.513", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>This is using a Python feature call \"lambda\". lambda are unnamed python function of 1 line. They have this forme:</p>\n\n<pre><code>lambda [param...]: code\n</code></pre>\n\n<p>In your example it is:</p>\n\n<pre><code>lambda prior_result, A: prior_result * A\n</code></pre>\n\n<p>This is a function that take prior_result and A as input. This function, is passed to the scan() function as the fn parameter. scan() will call it with 2 variables. The first one will be the correspondance of what was provided in the output_info parameter. The other is what is provided in the non_sequence parameter.</p>\n" } ]

[ { "AnswerId": "24186817", "CreationDate": "2014-06-12T14:22:19.933", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>You can do:</p>\n\n<pre><code>A[v]\n</code></pre>\n\n<p>It will do what you want.</p>\n" } ]

[ { "AnswerId": "24203540", "CreationDate": "2014-06-13T10:47:55.023", "ParentId": null, "OwnerUserId": "166749", "Title": null, "Body": "<p>No, this is not possible. NumPy arrays need to be rectangular in every pair of dimensions. This is due to the way they map onto memory buffers, as a pointer, itemsize, stride triple.</p>\n\n<p>As for this taking up space: <code>np.array([[1,2,3], [4,5]])</code> actually takes up more space than a 2×3 array, because it's an array of two pointers to Python lists (and even if the elements were converted to arrays, the memory layout would still be inefficient).</p>\n" }, { "AnswerId": "24206476", "CreationDate": "2014-06-13T13:26:46.603", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>I'll give here very new information about Theano. We have a new TypedList() type, that allow to have python list with all elements with the same type: like 1d ndarray. All is done, except the documentation.</p>\n\n<p>There is limited functionality you can do with them. But we did it to allow looping over the typed list with scan. It is not yet integrated with scan, but you can use it now like this:</p>\n\n<pre><code>import theano\nimport theano.typed_list\n\na = theano.typed_list.TypedListType(theano.tensor.fvector)()\ns, _ = theano.scan(fn=lambda i, tl: tl[i].sum(),\n non_sequences=[a],\n sequences=[theano.tensor.arange(2, dtype='int64')])\n\nf = theano.function([a], s)\nf([[1, 2, 3], [4, 5]])\n</code></pre>\n\n<p>One limitation is that the output of scan must be an ndarray, not a typed list.</p>\n" } ]

[ { "AnswerId": "30507375", "CreationDate": "2015-05-28T13:02:29.613", "ParentId": null, "OwnerUserId": "127480", "Title": null, "Body": "<p>The first option is probably the best option in most cases. It's what I do though it does mean passing around a separate vector of sentence lengths and masking certain results to eliminate the padding region when needed.</p>\n\n<p>In general, if you want to perform a consistent operation to all sentences then you'll usually get much better speed applying that operation to a single 3D tensor than sequentially to a series of matrices. This is especially true for operations running on a GPU.</p>\n\n<p>If you're using scan operations the speed differences will become even more magnified. You'll be better off scanning over a 3D tensor and operating on a per-word matrix in your step function that covers all (or a minibatch of) sentences. If needed, you may need to know which rows of that matrix are real data and which are padding. As an aside, I find that setting the first dimension of a 3D tensor to be the temporal/sequence position dimension helps when using scan, which always scans over the first dimension.</p>\n\n<p>Often, using the value zero as your padding value will result in the padding have no impact on your operations.</p>\n\n<p>The other option, looping over the sentences, would mean mixing Theano and Python code which can make some computations difficult or impossible. For example, getting the gradient of a cost function with respect to some parameters over a all (or batch) of your sentences may not be possible if the data is stored in lots of separate matrices.</p>\n" } ]

[ { "AnswerId": "24225977", "CreationDate": "2014-06-15T02:10:54.737", "ParentId": null, "OwnerUserId": "2357112", "Title": null, "Body": "<pre><code>&gt;&gt;&gt; type(numpy.sqrt(numpy.float32(2)))\n&lt;type 'numpy.float32'&gt;\n</code></pre>\n\n<p><code>numpy.sqrt</code> already does what you want. On the other hand, the <code>math</code> functions always cast their input to <code>float</code> and return <code>float</code>, with no option to change that. Stick with NumPy operations instead of the <code>math</code> module for NumPy data types, and you should be fine.</p>\n" } ]

[ { "AnswerId": "24329482", "CreationDate": "2014-06-20T14:22:41.983", "ParentId": null, "OwnerUserId": "3760518", "Title": null, "Body": "<p>Have a look at: <a href=\"https://stackoverflow.com/questions/15917849/how-can-i-assign-update-subset-of-tensor-shared-variable-in-theano\">How can I assign/update subset of tensor shared variable in Theano?</a></p>\n\n<p>For your code this translates to:</p>\n\n<pre><code>from theano import function, sandbox, shared\nimport theano.tensor as T\nimport numpy as np\n\nreservoirSize = 2\nsamples = 5\n\n# To initialize _mat first column\n_vec = np.asarray([1 for i in range(reservoirSize)], np.float32)\n\n# Random matrix, first column will be initialized correctly (_vec)\n_mat = np.asarray(np.random.rand(reservoirSize, samples), np.float32)\n_mat[:,0] = _vec\n\nprint \"Init:\\n\",_mat\n\n_mat = shared(_mat)\n\nidx = T.iscalar()\ntest = function([idx], updates= {\n # -&gt; instead of\n #_mat[:,idx]:sandbox.cuda.basic_ops.gpu_from_host(_mat[:,idx-1] * 2)\n # -&gt; do this:\n _mat:T.set_subtensor(_mat[:,idx], _mat[:,idx-1]*2) \n })\n\nfor i in range(1, samples):\n test(i)\n\nprint \"Done:\\n\",_mat.get_value() # use get_value() here to retrieve the data\n</code></pre>\n" } ]

[ { "AnswerId": "24244862", "CreationDate": "2014-06-16T13:25:57.407", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Typed list isn't used by anybody yet. But the idea for having them is that you iterate on them with scan for each sentence. Then you do everything you need in 1 scan. You don't do 1 scan for each operation.</p>\n\n<p>So the scan is only used to do the iteration on each example in the minibatch, and the inside of scan is all what is done on one example.</p>\n\n<p>We haven't tested typed list with grad yet. It is possible that it is missing some implementations.</p>\n" } ]

[ { "AnswerId": "24234094", "CreationDate": "2014-06-15T21:02:48.470", "ParentId": null, "OwnerUserId": "3741258", "Title": null, "Body": "<p>You can use function nesting:</p>\n\n<pre><code>def nest(f, g):\n def h(x):\n return f(g(x), x)\n return h\n\nexpr = lambda (a,b) : a\nexpr = nest((lambda x, (a, b): x + (a - b)), expr)\nexpr = nest((lambda x, (a, b): x + (a - b)), expr)\n\nprint expr((1,2)) # prints -1\n</code></pre>\n\n<p>Regarding the example code, you could do something like (modifying <code>nest</code> to use no arguments):</p>\n\n<pre><code>def nest(f, g):\n def h():\n return f(g())\n return h\n\nexpr = lambda: (_vec, _init)[1]\nexpr = nest(lambda x: T.set_subtensor(x[1], x[0] * 2)[1], expr)\nexpr = nest(lambda x: T.set_subtensor(x[2], x[1] * 2)[1], expr)\nexpr = nest(lambda x: T.set_subtensor(x[3], x[2] * 2)[1], expr)\nexpr = nest(lambda x: T.set_subtensor(x[4], x[3] * 2)[1], expr)\n\ntest_vector = function([], outputs=expr)\nsubt = test_vector()\n</code></pre>\n" } ]

[ { "AnswerId": "40622953", "CreationDate": "2016-11-16T02:11:18.507", "ParentId": null, "OwnerUserId": "3041068", "Title": null, "Body": "<p>There's now a built in function for this <a href=\"http://deeplearning.net/software/theano/library/tensor/extra_ops.html#theano.tensor.extra_ops.to_one_hot\" rel=\"nofollow noreferrer\"><code>theano.tensor.extra_ops.to_one_hot</code></a>.</p>\n\n<pre><code>y = tensor.as_tensor([3,2,1])\nfn = theano.function([], tensor.extra_ops.to_one_hot(y, 4))\nprint fn()\n# [[ 0. 0. 0. 1.]\n# [ 0. 0. 1. 0.]\n# [ 0. 1. 0. 0.]]\n</code></pre>\n" }, { "AnswerId": "24268694", "CreationDate": "2014-06-17T16:14:20.890", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>I didn't compare the different option, but you can also do it like this. It don't request extra memory.</p>\n\n<pre><code>import numpy as np\nimport theano\n\nn_val = 4\nv_val = np.asarray([1,0,3])\nidx = theano.tensor.lvector()\nz = theano.tensor.zeros((idx.shape[0], n_val))\none_hot = theano.tensor.set_subtensor(z[theano.tensor.arange(idx.shape[0]), idx], 1)\nf = theano.function([idx], one_hot)\nprint f(v_val)[[ 0. 1. 0. 0.]\n [ 1. 0. 0. 0.]\n [ 0. 0. 0. 1.]]\n</code></pre>\n" }, { "AnswerId": "24264952", "CreationDate": "2014-06-17T13:19:09.633", "ParentId": null, "OwnerUserId": "1099534", "Title": null, "Body": "<p>It's as simple as:</p>\n\n<pre><code>convert = t.eye(n,n)[v]\n</code></pre>\n\n<p>There still might be a more efficient solution that doesn't require building the whole identity matrix. This might be problematic for large n and short v's.</p>\n" } ]

[ { "AnswerId": "24314997", "CreationDate": "2014-06-19T19:41:47.303", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The traceback indicate that in the function equal_compuations(), we didn't cover all case, when doing some comparison.</p>\n\n<p>I have a PR with a fix for it here:</p>\n\n<pre><code>https://github.com/Theano/Theano/pull/1928\n</code></pre>\n\n<p>thanks for the report.</p>\n\n<p>Your [edit] section, indicate me that you cut some of the errors message. If this happear during optimization with a warning, it mean an optimization was just skipped. It is possible that the optimization just don't apply, but it could be possible that with the fix, now the optimization apply. If that is the case, there could be some speed up with the fix.</p>\n" } ]

[ { "AnswerId": "24410185", "CreationDate": "2014-06-25T13:33:15.273", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>If you update to the development version, it work for me:</p>\n\n<p><a href=\"http://www.deeplearning.net/software/theano/install.html#bleeding-edge-install-instructions\" rel=\"nofollow\">http://www.deeplearning.net/software/theano/install.html#bleeding-edge-install-instructions</a></p>\n\n<p>We try to keep the development version very stable and I recomment everybody to use it, since it contain many fixes since the last release.</p>\n\n<p>If that don't fix it, the error is specific to your OS or python version. We will need more information about it. Also always provide the full error message with the traceback. This provide much more debugging information.</p>\n" } ]

[ { "AnswerId": "24410773", "CreationDate": "2014-06-25T13:59:26.653", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>Theano support this out of the box. You have nothing particular to do. If Theano don't support something in the crash, it should raise an error. But you won't have it for this, if there isn't problem in the way you call it. But the current pseudo-code should work.</p>\n" } ]

[ { "AnswerId": "24409647", "CreationDate": "2014-06-25T13:10:35.310", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>This can be caused by many things. The error is related to the GPU. So first, make sure you can compile nvidia example and that they run fine. To be sure this isn't the problem.</p>\n\n<p>The problem is that Theano isn't able to import a GPU module it compiled, because he didn't found the symbol it need. This missing symbol \"_Z25CudaNdarray_CopyFromArrayP11CudaNdarrayP23tagPyArrayObject_fields\" is in a shared library that Theano already pre-compiled.</p>\n\n<p>What is your OS? Make sure to update to the latest development version of Theano. There was a fix recently (Monday if my memory is exact) that could solve this on some OS.</p>\n" } ]

[ { "AnswerId": "24437169", "CreationDate": "2014-06-26T17:57:21.027", "ParentId": null, "OwnerUserId": "2855342", "Title": null, "Body": "<p>I wouldn't say it does automatic \"unfolding\" - rather, Theano has a notion of what variables are connected, and can pass updates along that chain. If this is what you mean by unfolding, then maybe we are talking about the same thing. </p>\n\n<p>I am stepping through this as well, but using <a href=\"https://11350770138305416713.googlegroups.com/attach/2628c6c56beb34bf/rnn.py?part=0.1&amp;view=1&amp;vt=ANaJVrFlEcr9KydEXVwhub2Lhwv0bs8OZIc678NDDHXGzyPIfr39rH0EiiXXbi4Q9GHbNmAhFQzp7l3hapna0fV3lyR1ICmPe_rij_aL292mq8ioP2lccQg\" rel=\"nofollow noreferrer\">Rasvan Pascanu's rnn.py</a> code (from <a href=\"https://groups.google.com/forum/#!msg/theano-users/OcdVuTZ19Dc/3m1Xlb1xxmoJ\" rel=\"nofollow noreferrer\">this thread</a>) for reference. It seems much more straightforward for a learning example. </p>\n\n<p>You might gain some value from visualizing/drawing graphs from the <a href=\"http://deeplearning.net/software/theano/tutorial/printing_drawing.html\" rel=\"nofollow noreferrer\">tutorial</a>. There is also set of slides online with a <a href=\"http://www.cs.bham.ac.uk/~jxb/INC/l12.pdf\" rel=\"nofollow noreferrer\">simple drawing</a> that shows the diagram from a 1 layer \"unfolding\" of an RNN, which you discuss in your post. </p>\n\n<p>Specifically, look at the <code>step</code> function:</p>\n\n<pre><code>def step(u_t, h_tm1, W, W_in, W_out):\n h_t = TT.tanh(TT.dot(u_t, W_in) + TT.dot(h_tm1, W))\n y_t = TT.dot(h_t, W_out)\n return h_t, y_t\n</code></pre>\n\n<p>This function represents the \"simple recurrent net\" shown in <a href=\"http://www.cs.bham.ac.uk/~jxb/INC/l12.pdf\" rel=\"nofollow noreferrer\">these slides, pg 10</a>. When you do updates, you simply pass the gradient w.r.t. W, W_in, and W_out, respectively (remember that y is connected to those three via the <code>step</code> function! This is how the gradient magic works).</p>\n\n<p>If you had multiple W layers (or indexes into one big W, as I believe gwtaylor is doing), then that would create multiple layers of \"unfolding\". From what I understand, this network only looks 1 step backward in time. If it helps, <a href=\"https://github.com/lmjohns3/theano-nets\" rel=\"nofollow noreferrer\">theanonets</a> also has an RNN implementation in Theano.</p>\n\n<p>As an additional note, training RNNs with BPTT is <em>hard</em>. <a href=\"http://www.cs.utoronto.ca/~ilya/pubs/ilya_sutskever_phd_thesis.pdf\" rel=\"nofollow noreferrer\">Ilya Sutskever's dissertation</a> discusses this at great length - if you can, try to tie into a <a href=\"https://github.com/boulanni/theano-hf\" rel=\"nofollow noreferrer\">Hessian Free optimizer, there is also a reference RNN implementation here</a>. Theanets also does this, and may be a good reference.</p>\n" } ]

[ { "AnswerId": "29567965", "CreationDate": "2015-04-10T18:03:24.547", "ParentId": null, "OwnerUserId": "1318153", "Title": null, "Body": "<p>It looks like <a href=\"https://lists.macosforge.org/pipermail/macports-users/2010-November/022662.html\" rel=\"nofollow\">one possible solution</a> is to manually create a link to the .dylib file:</p>\n\n<blockquote>\n <p>sudo ln -sf\n /System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib\n /opt/local/lib/libGL.dylib</p>\n \n <p>sudo ln -sf\n /System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/ImageIO.framework/Versions/A/Resources/libPng.dylib\n /opt/local/lib/libpng.dylib</p>\n \n <p>sudo ln -sf\n /System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/ImageIO.framework/Versions/A/Resources/libTIFF.dylib\n /opt/local/lib/libtiff.dylib</p>\n \n <p>sudo ln -sf\n /System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/ImageIO.framework/Versions/A/Resources/libJPEG.dylib\n /opt/local/lib/libjpeg.dylib</p>\n \n <p>Why does this work? Because for whatever reason, when Apple requests\n libJPEG.dyld, whatever system searches for it finds\n /opt/local/lib/libjpeg.dyld because the search is case insensitive.\n For a Unix operating system. Go figure. The lines above will force any\n program looking for libjpeg.dyld to be redirected to Apple's\n libJPEG.dyld.</p>\n</blockquote>\n\n<p>Another user suggested <a href=\"http://comments.gmane.org/gmane.os.apple.macports.user/22154\" rel=\"nofollow\">setting DYLD_FALLBACK_LIBRARY_PATH</a>:</p>\n\n<blockquote>\n <p>You could also use DYLD_FALLBACK_LIBRARY_PATH. I had to use that to\n avoid Apple's libJPEG getting in the way of apps that expected the\n libjpeg port. See the man page for dlopen() for details.</p>\n</blockquote>\n" } ]

[ { "AnswerId": "24496769", "CreationDate": "2014-06-30T18:40:12.860", "ParentId": null, "OwnerUserId": "2855342", "Title": null, "Body": "<p>To summarize the findings:</p>\n\n<p>Assigning <code>grad_var = codes[idx]</code>, then making a new variable such as: \n<code>subgrad = T.set_subtensor(codes[input_index], codes[input_index] - learning_rate*del_codes[input_index])</code></p>\n\n<p>Then calling \n<code>train_codes = function([input_index], loss, updates = [[codes, subgrad]])</code></p>\n\n<p>seemed to do the trick. In general, I try to make variables for as many things as possible. Sometimes tricky problems can arise from trying to do too much in a single statement, plus it is hard to debug and understand later! Also, in this case I think theano needs a shared variable, but has issues if the shared variable is <em>created</em> inside the function that requires it. </p>\n\n<p>Glad this worked for you!</p>\n" } ]

[ { "AnswerId": "24738726", "CreationDate": "2014-07-14T14:20:27.470", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>See this link to update Theano to the development version. I should be fixed:</p>\n\n<p><a href=\"http://deeplearning.net/software/theano/install.html#bleeding-edge-install-instructions\" rel=\"nofollow\">http://deeplearning.net/software/theano/install.html#bleeding-edge-install-instructions</a></p>\n\n<p>In resume, run one of those 2 command:</p>\n\n<pre><code>pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git\n</code></pre>\n\n<p>or (if you want to install it for the current user only):</p>\n\n<pre><code>pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git --user\n</code></pre>\n" } ]

[ { "AnswerId": "24709025", "CreationDate": "2014-07-12T02:26:05.297", "ParentId": null, "OwnerUserId": "949321", "Title": null, "Body": "<p>The problem is that the old version wasn't installed with pip, but probably with easy_install. This cause many type of problems.</p>\n\n<p>You can fix it by changing the import order after starting python. To do so, in your python script before importing theano do something like this:</p>\n\n<pre><code>import sys\nsys.path[0:0] = [\"THE_PYTHON_PATH_YOU_WANT_TO_ADD\"]\n</code></pre>\n\n<p>THE_PYTHON_PATH_YOU_WANT_TO_ADD is something like <code>~/.local/lib/python2.7/site-packages/</code></p>\n" } ]

[ { "AnswerId": "24540875", "CreationDate": "2014-07-02T20:55:42.133", "ParentId": null, "OwnerUserId": "1460123", "Title": null, "Body": "<p>The problem was resolved after removing ATLAS, installing OpenBLAS, reinstalling numpy + scipy + theano, and then installing Pylearn2 from source. </p>\n\n<p>See <a href=\"https://github.com/Theano/Theano/blob/master/doc/install_ubuntu.txt#L70\" rel=\"nofollow\">https://github.com/Theano/Theano/blob/master/doc/install_ubuntu.txt#L70</a> of the Theano install guide for a more detailed explanation.</p>\n" } ]

[ { "AnswerId": "24626805", "CreationDate": "2014-07-08T08:15:09.180", "ParentId": null, "OwnerUserId": "2855342", "Title": null, "Body": "<p>In one word: yes.</p>\n\n<p>To see the result of the operation, use <code>result.eval()</code></p>\n\n<p>Minimal working example:</p>\n\n<pre><code>import numpy as np\nimport theano\nfrom theano import tensor as T\nw_values = np.random.randn(1152, 10).astype(theano.config.floatX)\ninput_values = np.random.randn(1152, 1).astype(theano.config.floatX)\nw = theano.shared(w_values, 'w')\ninput = theano.shared(input_values, 'input')\nresult = T.dot(input.T, w)\nprint(result.eval())\n</code></pre>\n" } ]

[ { "AnswerId": "24609262", "CreationDate": "2014-07-07T11:12:53.310", "ParentId": null, "OwnerUserId": "2855342", "Title": null, "Body": "<p>You can get this using <code>T.sgn()</code> since the sign of 0 is 0, though it will probably still fail for very, very small values <em>near</em> 0</p>\n\n<p>Minimal example</p>\n\n<pre><code>import numpy as np\nimport theano\nfrom theano import tensor as T\n\nX_values = np.arange(10).astype(theano.config.floatX)\nX = T.shared(X_values, 'X')\nY = (X ** (-1 * abs(T.sgn(X)))) * abs(T.sgn(X))\nprint(Y.eval())\n</code></pre>\n\n<p>I think what user189 was saying is that mathematically this is not really correct - the result <em>should</em> go to infinity as the denominator approaches 0. What is the application where you need this? You can always test for T.isinf and T.isnan to try and catch numerical problems without resorting to tricks, and raising an exception is probably a cleaner approach than altering the math.</p>\n" } ]