Skip to content

P
pytensor
提交 e789f49c authored 作者: Razvan Pascanu's avatar Razvan Pascanu
浏览文件
操作

tutorial fix

上级 68f41e1c a69de34a
显示空白字符变更
内嵌 并排
正在显示 包含 1111 行增加 和 984 行删除
doc/images/theano_logo.svg deleted 100644 → 0
浏览文件 @ 68f41e1c
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://web.resource.org/cc/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="345.86591"
height="115.13724"
id="svg2"
sodipodi:version="0.32"
inkscape:version="0.45.1"
sodipodi:docbase="/home/olivier/hg/theano"
sodipodi:docname="theano_logo.svg"
inkscape:output_extension="org.inkscape.output.svg.inkscape"
version="1.0"
inkscape:export-filename="/home/olivier/hg/theano/theano_logo_big.png"
inkscape:export-xdpi="273.58655"
inkscape:export-ydpi="273.58655">
<defs
id="defs4" />
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1.0"
gridtolerance="10000"
guidetolerance="10"
objecttolerance="10"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
inkscape:zoom="1.979899"
inkscape:cx="248.50886"
inkscape:cy="97.530852"
inkscape:document-units="px"
inkscape:current-layer="layer1"
inkscape:window-width="1680"
inkscape:window-height="1030"
inkscape:window-x="0"
inkscape:window-y="0"
showguides="true"
inkscape:guide-bbox="true" />
<metadata
id="metadata7">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
</cc:Work>
</rdf:RDF>
</metadata>
<g
inkscape:label="Layer 1"
inkscape:groupmode="layer"
id="layer1"
transform="translate(-219.06115,-88.23416)">
<path
id="path5572"
d="M 245.99986,202.38198 C 235.76172,199.76305 230.3317,195.18454 224.56469,184.30815 C 220.37775,176.41173 219.14676,170.92373 219.06742,159.80009 C 219.02952,154.48681 219.14363,153.33451 219.96737,150.71192 L 220.91072,147.70853 L 222.03485,150.91475 C 223.32792,154.60284 224.5932,157.2101 225.42491,157.90035 C 225.91931,158.31066 226.04839,157.45384 226.31509,151.99127 C 226.48664,148.47733 226.74177,144.59829 226.88203,143.3712 C 227.13637,141.14611 227.14306,141.13711 229.37079,140.02194 C 233.6165,137.89661 241.51289,137.62549 255.7355,139.11671 C 262.25557,139.80033 276.27711,139.65881 278.302,138.88894 C 280.15154,138.18575 280.55926,136.52884 280.07117,131.69921 C 279.49474,125.99537 279.0548,124.08561 277.22091,119.32634 C 272.4649,106.98367 264.75123,100.69911 254.31572,100.6648 C 244.91721,100.6339 237.20308,106.18784 232.64521,116.26692 C 228.63554,125.13371 226.84755,134.63837 225.79128,152.70119 L 225.49476,157.77183 L 224.6018,156.08339 C 220.32764,148.00176 218.55416,134.3005 220.39244,123.56361 C 221.81624,115.24763 224.72248,108.02444 229.43922,101.07873 C 233.51167,95.08179 239.33503,91.22689 247.37024,89.20891 C 252.54529,87.90924 256.08615,87.90924 261.2612,89.20891 C 269.29641,91.22689 275.11977,95.08179 279.19222,101.07873 C 283.85913,107.95107 286.81123,115.24029 288.1872,123.28884 C 289.11587,128.72102 289.26704,136.96138 288.48572,139.5625 C 287.80095,141.84221 282.75423,149.25874 282.58446,148.23482 C 282.51467,147.81394 282.66002,147.09129 282.90745,146.62895 C 283.60255,145.33016 282.97412,144.79606 281.91813,145.78812 C 281.09814,146.55845 280.95497,146.57992 280.4772,146.00425 C 279.46931,144.78981 279.09827,146.0508 280.02317,147.54731 C 281.09294,149.27824 281.11194,149.86163 280.09855,149.86163 C 279.6655,149.86163 279.2114,150.02307 279.08945,150.2204 C 278.12451,151.78171 263.15706,152.14918 251.27333,150.90331 C 242.48708,149.98217 235.49959,150.17874 233.86598,151.393 C 232.52086,152.39282 230.73981,155.92513 230.13832,158.78596 C 229.56685,161.50406 229.89814,169.75383 230.71167,173.06316 C 231.53272,176.40313 234.44347,181.26714 237.48117,184.37536 C 245.97324,193.06457 259.99042,193.16426 268.52866,184.59618 C 272.82158,180.28826 276.28725,173.36771 275.26986,171.13477 C 275.01206,170.56897 274.80113,169.46845 274.80113,168.68918 C 274.80113,167.27252 276.03299,164.34881 276.84003,163.85004 C 277.97809,163.14668 279.2633,160.34344 279.2633,158.56453 C 279.2633,156.50464 279.81574,155.1351 280.64665,155.1351 C 281.94053,155.1351 281.78744,149.84815 280.42796,147.58266 C 279.38328,145.84176 279.47773,145.48404 280.68309,146.61641 C 281.46075,147.34699 281.69721,147.42235 281.69721,146.93962 C 281.69721,146.59338 282.00521,146.05957 282.38164,145.75336 C 282.9932,145.2559 283.02559,145.28301 282.68588,146.00793 C 282.47678,146.45415 282.35906,148.62448 282.4243,150.8309 C 282.5319,154.47038 282.63024,154.91126 283.48431,155.58307 C 284.25335,156.18799 284.4647,156.82757 284.6386,159.07597 C 284.78839,161.01273 285.24037,162.64716 286.16384,164.59151 C 287.23183,166.84012 287.43789,167.69463 287.27043,169.18035 C 287.15459,170.2081 286.70684,171.3939 286.24597,171.89349 C 285.2295,172.99536 281.11174,180.12521 280.69642,181.50246 C 279.94371,183.99856 277.41503,189.23736 275.76462,191.71994 C 273.21329,195.55768 270.45935,197.86457 265.70147,200.14953 C 258.59319,203.56326 253.06615,204.18955 245.99986,202.38198 z "
style="fill:#000000;fill-opacity:1" />
<text
xml:space="preserve"
style="font-size:15.53327274px;font-style:normal;font-weight:normal;fill:#7799ee;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
x="285.01266"
y="186.09427"
id="text5574"
transform="scale(1.0402212,0.961334)"><tspan
sodipodi:role="line"
id="tspan5576"
x="285.01266"
y="186.09427"
style="font-size:93.19962311px;font-weight:normal;fill:#7799ee;fill-opacity:1;font-family:MgOpen Modata"
dx="0 -4.2857141 -6.4285722 -5 -5.7142901 -6.0714293"
dy="0 0 -1.3672954 0.35714287 1.0101526 -1.0101526">Theano</tspan></text>
</g>
</svg>
doc/internal/dev_start_guide.txt
浏览文件 @ e789f49c
...@@ -41,13 +41,13 @@ As a developer, you should clone this repository like this: ...@@ -41,13 +41,13 @@ As a developer, you should clone this repository like this:
.. code-block:: bash .. code-block:: bash
hg clone 'http://username:password@pylearn.org/hg/Theano' hg clone 'http://username:password@hg.assembla.com/theano Theano'
You can also clone the code anonymously: You can also clone the code anonymously:
.. code-block:: bash .. code-block:: bash
hg clone http://pylearn.org/hg/Theano hg clone http://hg.assembla.com/theano Theano
Setting up your environment Setting up your environment
=========================== ===========================
......
doc/library/compile/index.txt
浏览文件 @ e789f49c
...@@ -15,11 +15,13 @@ ...@@ -15,11 +15,13 @@
TODO TODO
.. _libdoc_compile_function:
compile.function compile.function
================ ================
This page is about :api:`theano.function This page is about `theano.function`, the interface for compiling
<theano.compile.function_module.function>`, the interface for compiling
graphs into callable objects. graphs into callable objects.
The signature for this function is: The signature for this function is:
...@@ -402,6 +404,11 @@ For a finer level of control over which optimizations are applied, and whether ...@@ -402,6 +404,11 @@ For a finer level of control over which optimizations are applied, and whether
C or python implementations are used, read :api:`compile.mode.Mode`. C or python implementations are used, read :api:`compile.mode.Mode`.
.. _compile_debugMode:
DebugMode ??
.. toctree:: .. toctree::
function function
......
doc/library/tensor/basic.txt
浏览文件 @ e789f49c
.. currentmodule:: tensor .. currentmodule:: tensor
.. _libdoc_tensor_type:
TensorType TensorType
========== ==========
...@@ -9,6 +13,10 @@ TensorType ...@@ -9,6 +13,10 @@ TensorType
.. method:: quux() .. method:: quux()
.. _libdoc_tensor_creation:
Creation Creation
======== ========
...@@ -72,6 +80,9 @@ Basic indexing. ...@@ -72,6 +80,9 @@ Basic indexing.
Advanced indexing. Advanced indexing.
.. _libdoc_tensor_elementwise:
Elementwise Elementwise
=========== ===========
...@@ -84,9 +95,57 @@ Logic Functions ...@@ -84,9 +95,57 @@ Logic Functions
Mathematical Mathematical
------------ ------------
.. _libdoc_tensor_broadcastable:
Broadcasting in Theano vs. Numpy Broadcasting in Theano vs. Numpy
-------------------------------- --------------------------------
Broadcasting is a mechanism which allows tensors with
different numbers of dimensions to be added or multiplied
together by (virtually) replicating the smaller tensor along
the dimensions that it is lacking.
In a nutshell, broadcasting is the mechanism by which a scalar
may be added to a matrix, a vector to a matrix or a scalar to
a vector.
.. figure:: bcast.png
Broadcasting a row matrix. T and F respectively stand for
True and False and indicate along which dimensions we allow
broadcasting.
If the second argument were a vector, its shape would be
``(2,)`` and its broadcastable pattern ``(F,)``. They would
be automatically expanded to the **left** to match the
dimensions of the matrix (adding ``1`` to the shape and ``T``
to the pattern), resulting in ``(1, 2)`` and ``(T, F)``.
It would then behave just like the example above.
Unlike numpy which does broadcasting dynamically, Theano needs
to know, for any operation which supports broadcasting, which
dimensions will need to be broadcasted. When applicable, this
information is given in the :ref:`type` of a *Variable*.
See also:
* :ref:`How broadcasting is used in Theano's tensor types <tensortypes>`
* `SciPy documentation about numpy's broadcasting <http://www.scipy.org/EricsBroadcastingDoc>`_
* `OnLamp article about numpy's broadcasting <http://www.onlamp.com/pub/a/python/2000/09/27/numerically.html>`_
Linear Algebra Linear Algebra
============== ==============
Fourier Transforms
==================
[James has some code for this, but hasn't gotten it into the source tree yet.]
=
doc/library/tensor/bcast.svg 0 → 100644
浏览文件 @ e789f49c
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://web.resource.org/cc/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="144.18471"
height="188.09711"
id="svg2"
sodipodi:version="0.32"
inkscape:version="0.45.1"
sodipodi:docbase="/u/breuleuo/hg/theano/doc"
sodipodi:docname="bcast.svg"
inkscape:output_extension="org.inkscape.output.svg.inkscape"
version="1.0"
inkscape:export-filename="/u/breuleuo/hg/theano/doc/bcast.png"
inkscape:export-xdpi="249.67973"
inkscape:export-ydpi="249.67973">
<defs
id="defs4">
<marker
inkscape:stockid="Arrow2Lend"
orient="auto"
refY="0"
refX="0"
id="Arrow2Lend"
style="overflow:visible">
<path
id="path3247"
style="font-size:12px;fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.97309,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
</marker>
<marker
inkscape:stockid="Arrow1Lend"
orient="auto"
refY="0"
refX="0"
id="Arrow1Lend"
style="overflow:visible">
<path
id="path3229"
d="M 0,0 L 5,-5 L -12.5,0 L 5,5 L 0,0 z "
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
transform="matrix(-0.8,0,0,-0.8,-10,0)" />
</marker>
</defs>
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1.0"
gridtolerance="10000"
guidetolerance="10"
objecttolerance="10"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
inkscape:zoom="2.8"
inkscape:cx="55.423257"
inkscape:cy="90.829331"
inkscape:document-units="px"
inkscape:current-layer="layer1"
inkscape:window-width="1272"
inkscape:window-height="937"
inkscape:window-x="0"
inkscape:window-y="0" />
<metadata
id="metadata7">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
</cc:Work>
</rdf:RDF>
</metadata>
<g
inkscape:label="Layer 1"
inkscape:groupmode="layer"
id="layer1"
transform="translate(-106.70114,-419.13306)">
<text
xml:space="preserve"
style="font-size:12px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
x="116.79369"
y="428.03931"
id="text2160"><tspan
sodipodi:role="line"
id="tspan2162"
x="116.79369"
y="428.03931"
style="font-family:Monospace">1 2</tspan><tspan
sodipodi:role="line"
x="116.79369"
y="443.03931"
id="tspan2164"
style="font-family:Monospace">3 4</tspan><tspan
sodipodi:role="line"
x="116.79369"
y="458.03931"
id="tspan2166"
style="font-family:Monospace">5 6</tspan></text>
<text
xml:space="preserve"
style="font-size:12px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
x="180.75143"
y="506.09698"
id="text2184"><tspan
sodipodi:role="line"
id="tspan2186"
x="180.75143"
y="506.09698"
style="font-family:Monospace">1 2</tspan><tspan
sodipodi:role="line"
x="180.75143"
y="521.09698"
id="tspan2188"
style="fill:#0000ff;font-family:Monospace">1 2</tspan><tspan
sodipodi:role="line"
x="180.75143"
y="536.09698"
id="tspan2190"
style="fill:#0000ff;font-family:Monospace">1 2</tspan></text>
<text
xml:space="preserve"
style="font-size:12px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
x="150.42657"
y="577.06024"
id="text2192"><tspan
sodipodi:role="line"
id="tspan2194"
x="150.42657"
y="577.06024"
style="font-family:Monospace">2 4</tspan><tspan
sodipodi:role="line"
x="150.42657"
y="592.06024"
id="tspan2196"
style="font-family:Monospace">4 6</tspan><tspan
sodipodi:role="line"
x="150.42657"
y="607.06024"
id="tspan2198"
style="font-family:Monospace">6 8</tspan></text>
<text
xml:space="preserve"
style="font-size:12px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
x="180.81337"
y="428.06268"
id="text2200"><tspan
sodipodi:role="line"
x="180.81337"
y="428.06268"
id="tspan2206"
style="font-family:Monospace">1 2</tspan><tspan
sodipodi:role="line"
x="180.81337"
y="443.06268"
style="font-family:Monospace"
id="tspan2208" /><tspan
sodipodi:role="line"
x="180.81337"
y="458.06268"
style="font-family:Monospace"
id="tspan2210" /></text>
<text
xml:space="preserve"
style="font-size:12px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
x="156.64333"
y="442.89511"
id="text2216"><tspan
sodipodi:role="line"
x="156.64333"
y="442.89511"
id="tspan2218"
style="font-family:Monospace">+</tspan><tspan
sodipodi:role="line"
x="156.64333"
y="457.89511"
style="font-family:Monospace"
id="tspan2220" /><tspan
sodipodi:role="line"
x="156.64333"
y="472.89511"
style="font-family:Monospace"
id="tspan2222" /></text>
<text
xml:space="preserve"
style="font-size:6px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
x="106.13571"
y="465.37097"
id="text2224"><tspan
sodipodi:role="line"
x="106.13571"
y="465.37097"
id="tspan2226"
style="font-size:6px;font-family:Monospace">shape: (3, 2)</tspan><tspan
sodipodi:role="line"
x="106.13571"
y="472.87097"
style="font-size:6px;font-family:Monospace"
id="tspan2240">bcast: (F, F)</tspan><tspan
sodipodi:role="line"
x="106.13571"
y="480.37097"
style="font-size:6px;font-family:Monospace"
id="tspan2228" /><tspan
sodipodi:role="line"
x="106.13571"
y="487.87097"
style="font-size:6px;font-family:Monospace"
id="tspan2230" /></text>
<text
xml:space="preserve"
style="font-size:6px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
x="168.05223"
y="465.34521"
id="text2232"><tspan
sodipodi:role="line"
x="168.05223"
y="465.34521"
id="tspan2234"
style="font-size:6px;font-family:Monospace">shape: (1, 2)</tspan><tspan
sodipodi:role="line"
x="168.05223"
y="472.84521"
style="font-size:6px;font-family:Monospace"
id="tspan2242">bcast: (<tspan
style="fill:#0000ff"
id="tspan2244">T</tspan>, F)</tspan><tspan
sodipodi:role="line"
x="168.05223"
y="480.34521"
style="font-size:6px;font-family:Monospace"
id="tspan2236" /><tspan
sodipodi:role="line"
x="168.05223"
y="487.84521"
style="font-size:6px;font-family:Monospace"
id="tspan2238" /></text>
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.5;stroke-linecap:butt;stroke-linejoin:miter;marker-end:url(#Arrow2Lend);stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="M 161.11933,479.10061 L 161.37187,491.98006"
id="path2248" />
<text
id="text3469"
y="506.03931"
x="116.79369"
style="font-size:12px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
xml:space="preserve"><tspan
style="font-family:Monospace"
y="506.03931"
x="116.79369"
id="tspan3471"
sodipodi:role="line">1 2</tspan><tspan
style="font-family:Monospace"
id="tspan3473"
y="521.03931"
x="116.79369"
sodipodi:role="line">3 4</tspan><tspan
style="font-family:Monospace"
id="tspan3475"
y="536.03931"
x="116.79369"
sodipodi:role="line">5 6</tspan></text>
<text
id="text3485"
y="520.89514"
x="156.64333"
style="font-size:12px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
xml:space="preserve"><tspan
style="font-family:Monospace"
id="tspan3487"
y="520.89514"
x="156.64333"
sodipodi:role="line">+</tspan><tspan
id="tspan3489"
style="font-family:Monospace"
y="535.89514"
x="156.64333"
sodipodi:role="line" /><tspan
id="tspan3491"
style="font-family:Monospace"
y="550.89514"
x="156.64333"
sodipodi:role="line" /></text>
<text
id="text3493"
y="543.37097"
x="106.13571"
style="font-size:6px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
xml:space="preserve"><tspan
style="font-size:6px;font-family:Monospace"
id="tspan3495"
y="543.37097"
x="106.13571"
sodipodi:role="line">shape: (3, 2)</tspan><tspan
id="tspan3497"
style="font-size:6px;font-family:Monospace"
y="550.87097"
x="106.13571"
sodipodi:role="line">bcast: (F, F)</tspan><tspan
id="tspan3499"
style="font-size:6px;font-family:Monospace"
y="558.37097"
x="106.13571"
sodipodi:role="line" /><tspan
id="tspan3501"
style="font-size:6px;font-family:Monospace"
y="565.87097"
x="106.13571"
sodipodi:role="line" /></text>
<text
id="text3503"
y="543.34521"
x="168.05223"
style="font-size:6px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
xml:space="preserve"><tspan
style="font-size:6px;font-family:Monospace"
id="tspan3505"
y="543.34521"
x="168.05223"
sodipodi:role="line">shape: (<tspan
style="fill:#0000ff"
id="tspan3515">3</tspan>, 2)</tspan><tspan
id="tspan3507"
style="font-size:6px;font-family:Monospace"
y="550.84521"
x="168.05223"
sodipodi:role="line">bcast: (<tspan
id="tspan3509"
style="fill:#0000ff">T</tspan>, F)</tspan><tspan
id="tspan3511"
style="font-size:6px;font-family:Monospace"
y="558.34521"
x="168.05223"
sodipodi:role="line" /><tspan
id="tspan3513"
style="font-size:6px;font-family:Monospace"
y="565.84521"
x="168.05223"
sodipodi:role="line" /></text>
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.81574231;stroke-linecap:butt;stroke-linejoin:miter;marker-end:url(#Arrow2Lend);stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="M 209.4424,497.10811 L 209.6746,534.39419"
id="path3517" />
<text
id="text3519"
y="517.36304"
x="211.73936"
style="font-size:6px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Aharoni CLM"
xml:space="preserve"><tspan
id="tspan3523"
style="font-size:6px;font-family:Monospace"
y="517.36304"
x="211.73936"
sodipodi:role="line">broadcasted</tspan><tspan
id="tspan3525"
style="font-size:6px;font-family:Monospace"
y="524.86304"
x="211.73936"
sodipodi:role="line" /><tspan
id="tspan3527"
style="font-size:6px;font-family:Monospace"
y="532.36304"
x="211.73936"
sodipodi:role="line" /></text>
<path
id="path3533"
d="M 161.11933,553.10061 L 161.37187,565.98006"
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.5;stroke-linecap:butt;stroke-linejoin:miter;marker-end:url(#Arrow2Lend);stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
</g>
</svg>
doc/library/tensor/index.txt
浏览文件 @ e789f49c
...@@ -11,6 +11,7 @@ Theano's strength is in expressing symbolic calculations involving tensors. ...@@ -11,6 +11,7 @@ Theano's strength is in expressing symbolic calculations involving tensors.
There are many types of symbolic expressions for tensors. For everyone's There are many types of symbolic expressions for tensors. For everyone's
sanity, they are grouped into the following sections: sanity, they are grouped into the following sections:
.. toctree:: .. toctree::
:maxdepth: 1 :maxdepth: 1
......
doc/tutorial/adding.txt
浏览文件 @ e789f49c
...@@ -8,8 +8,8 @@ Baby steps - Adding two numbers together ...@@ -8,8 +8,8 @@ Baby steps - Adding two numbers together
Adding two scalars Adding two scalars
================== ==================
So, to get us started and get a feel of what we're working with, let's So, to get us started with Theano and get a feel of what we're working with,
make a simple function: add two numbers together. Here is how you do let's make a simple function: add two numbers together. Here is how you do
it: it:
>>> x = T.dscalar('x') >>> x = T.dscalar('x')
...@@ -26,17 +26,31 @@ array(28.4) ...@@ -26,17 +26,31 @@ array(28.4)
Let's break this down into several steps. The first step is to define Let's break this down into several steps. The first step is to define
two symbols, or Variables, representing the quantities that you want two symbols (*Variables*) representing the quantities that you want
to add. Note that from now on, we will use the term :term:`Variable` to add. Note that from now on, we will use the term
to mean "symbol" (in other words, ``x``, ``y``, ``z`` are all Variable *Variable* to mean "symbol" (in other words,
objects). The output of the function ``f`` is a ``numpy.ndarray`` ``x``, ``y``, ``z`` are all *Variable* objects). The output of the function
with zero dimensions. ``f`` is a ``numpy.ndarray`` with zero dimensions.
If you are following along and typing into an interpreter, you may have If you are following along and typing into an interpreter, you may have
noticed that there was a slight delay in executing the ``function`` noticed that there was a slight delay in executing the ``function``
instruction. Behind the scenes, ``f`` was being compiled into C code. instruction. Behind the scenes, ``f`` was being compiled into C code.
.. TODO: help
.. note:
A *Variable* is the main data structure you work with when
using Theano. The symbolic inputs that you operate on are
*Variables* and what you get from applying various operations to
these inputs are also *Variables*. For example, when I type
>>> x = theano.tensor.ivector()
>>> y = -x
``x`` and ``y`` are both Variables, i.e. instances of the
``theano.gof.graph.Variable`` class. The
type of both ``x`` and ``y`` is ``theano.tensor.ivector``.
------------------------------------------- -------------------------------------------
...@@ -47,11 +61,11 @@ instruction. Behind the scenes, ``f`` was being compiled into C code. ...@@ -47,11 +61,11 @@ instruction. Behind the scenes, ``f`` was being compiled into C code.
In Theano, all symbols must be typed. In particular, ``T.dscalar`` In Theano, all symbols must be typed. In particular, ``T.dscalar``
is the type we assign to "0-dimensional arrays (`scalar`) of doubles is the type we assign to "0-dimensional arrays (`scalar`) of doubles
(`d`)". It is a Theano :term:`Type`. (`d`)". It is a Theano :ref:`type`.
``dscalar`` is not a class. Therefore, neither ``x`` nor ``y`` ``dscalar`` is not a class. Therefore, neither ``x`` nor ``y``
are actually instances of ``dscalar``. They are instances of are actually instances of ``dscalar``. They are instances of
:api:`TensorVariable <theano.tensor.basic.TensorVariable>`. ``x`` and ``y`` :ref:`TensorVariable <libdoc_tensor_type>`. ``x`` and ``y``
are, however, assigned the theano Type ``dscalar`` in their ``type`` are, however, assigned the theano Type ``dscalar`` in their ``type``
field, as you can see here: field, as you can see here:
...@@ -64,8 +78,10 @@ TensorType(float64, scalar) ...@@ -64,8 +78,10 @@ TensorType(float64, scalar)
>>> x.type == T.dscalar >>> x.type == T.dscalar
True True
You can learn more about the structures in Theano in :ref:`graphstructures`.
By calling ``T.dscalar`` with a string argument, you create a By calling ``T.dscalar`` with a string argument, you create a
:term:`Variable` representing a floating-point scalar quantity with the *Variable* representing a floating-point scalar quantity with the
given name. If you provide no argument, the symbol will be unnamed. Names given name. If you provide no argument, the symbol will be unnamed. Names
are not required, but they can help debugging. are not required, but they can help debugging.
...@@ -77,8 +93,8 @@ The second step is to combine ``x`` and ``y`` into their sum ``z``: ...@@ -77,8 +93,8 @@ The second step is to combine ``x`` and ``y`` into their sum ``z``:
>>> z = x + y >>> z = x + y
``z`` is yet another :term:`Variable` which represents the addition of ``z`` is yet another *Variable* which represents the addition of
``x`` and ``y``. You can use the :api:`pp <theano.printing.pp>` ``x`` and ``y``. You can use the :ref:`pp <libdoc_printing>`
function to pretty-print out the computation associated to ``z``. function to pretty-print out the computation associated to ``z``.
>>> print pp(z) >>> print pp(z)
...@@ -93,7 +109,7 @@ and giving ``z`` as output: ...@@ -93,7 +109,7 @@ and giving ``z`` as output:
>>> f = function([x, y], z) >>> f = function([x, y], z)
The first argument to ``function`` is a list of :term:`Variables <Variable>` The first argument to :ref:`function <libdoc_compile_function>` is a list of Variables
that will be provided as inputs to the function. The second argument that will be provided as inputs to the function. The second argument
is a single Variable *or* a list of Variables. For either case, the second is a single Variable *or* a list of Variables. For either case, the second
argument is what we want to see as output when we apply the function. argument is what we want to see as output when we apply the function.
...@@ -130,7 +146,7 @@ array([[ 11., 22.], ...@@ -130,7 +146,7 @@ array([[ 11., 22.],
It is possible to add scalars to matrices, vectors to matrices, It is possible to add scalars to matrices, vectors to matrices,
scalars to vectors, etc. The behavior of these operations is defined scalars to vectors, etc. The behavior of these operations is defined
by :term:`broadcasting`. by :ref:`broadcasting <libdoc_tensor_broadcastable>`.
The following types are available: The following types are available:
......
doc/tutorial/debug_faq.txt
浏览文件 @ e789f49c
...@@ -110,9 +110,7 @@ put logic inside of the print_eval function that would, for example, only ...@@ -110,9 +110,7 @@ put logic inside of the print_eval function that would, for example, only
print something out if a certain kind of Op was used, at a certain program print something out if a certain kind of Op was used, at a certain program
position, or if a particular value shows up in one of the inputs or outputs. position, or if a particular value shows up in one of the inputs or outputs.
This can be a really powerful debugging tool. Read about more things you can .. TODO: documentation for link.WrapLinkerMany
do with :api:`link.WrapLinkerMany`.
Note well the call to ``fn`` inside the call to ``print_eval``; without it, This can be a really powerful debugging tool. Note the call to ``fn`` inside the call to ``print_eval``; without it, the graph wouldn't get computed at all!
the graph wouldn't get computed at all!
doc/tutorial/debugmode.txt
浏览文件 @ e789f49c
...@@ -7,7 +7,7 @@ Using DebugMode ...@@ -7,7 +7,7 @@ Using DebugMode
The DebugMode evaluation mode (available via ``mode='DEBUG_MODE'``, The DebugMode evaluation mode (available via ``mode='DEBUG_MODE'``,
:api:`DebugMode`) includes a number of self-checks and assertions that see :ref:`this <function_mode>`) includes a number of self-checks and assertions that
can help to diagnose several kinds of programmer errors that can lead can help to diagnose several kinds of programmer errors that can lead
to incorrect output. to incorrect output.
...@@ -41,7 +41,7 @@ In the example above, there is no way to guarantee that a future call to say, ...@@ -41,7 +41,7 @@ In the example above, there is no way to guarantee that a future call to say,
If you instantiate DebugMode using the constructor ``compile.DebugMode`` If you instantiate DebugMode using the constructor ``compile.DebugMode``
rather than the keyword ``DEBUG_MODE`` you can configure its behaviour via rather than the keyword ``DEBUG_MODE`` you can configure its behaviour via
constructor arguments. See :api:`DebugMode` for details. constructor arguments. See :ref:`DebugMode <compile_debugMode>` for details.
The keyword version of DebugMode (which you get by using ``mode='DEBUG_MODE``) The keyword version of DebugMode (which you get by using ``mode='DEBUG_MODE``)
is quite strict, and can raise several different Exception types. is quite strict, and can raise several different Exception types.
...@@ -56,7 +56,6 @@ This error is typically not raised directly. ...@@ -56,7 +56,6 @@ This error is typically not raised directly.
However, you can use ``except DebugModeError: ...`` to catch any of the more However, you can use ``except DebugModeError: ...`` to catch any of the more
specific types of Exception. specific types of Exception.
For detailed documentation see :api:`DebugModeError`.
BadCLinkerOutput BadCLinkerOutput
...@@ -66,7 +65,6 @@ This exception means that python (``perform``) and c (``c_code``) for an Op ...@@ -66,7 +65,6 @@ This exception means that python (``perform``) and c (``c_code``) for an Op
didn't compute the same thing like they were supposed to. didn't compute the same thing like they were supposed to.
The problem might be a bug in either ``perform`` or ``c_code`` (or both). The problem might be a bug in either ``perform`` or ``c_code`` (or both).
For detailed documentation see :api:`BadCLinkerOutput`.
BadOptimization BadOptimization
...@@ -82,7 +80,6 @@ exception object will indicate which optimization was at fault. ...@@ -82,7 +80,6 @@ exception object will indicate which optimization was at fault.
The exception object also contains information such as a snapshot of the The exception object also contains information such as a snapshot of the
before/after graph where the optimization introduced the error. before/after graph where the optimization introduced the error.
For detailed documentation see :api:`BadOptimization`.
BadDestroyMap BadDestroyMap
...@@ -93,7 +90,6 @@ supposed to. If either the ``perform`` or ``c_code`` implementation of an Op ...@@ -93,7 +90,6 @@ supposed to. If either the ``perform`` or ``c_code`` implementation of an Op
might modify any input, it has to advertise that fact via the ``destroy_map`` might modify any input, it has to advertise that fact via the ``destroy_map``
attribute. attribute.
For detailed documentation on the Exception, see :api:`BadDestroyMap`.
For detailed documentation on the ``destroy_map`` attribute, see :ref:`inplace`. For detailed documentation on the ``destroy_map`` attribute, see :ref:`inplace`.
...@@ -105,7 +101,6 @@ This happens when an Op's perform() or c_code() creates an alias or alias-like ...@@ -105,7 +101,6 @@ This happens when an Op's perform() or c_code() creates an alias or alias-like
dependency between an input and an output... and it didn't warn the dependency between an input and an output... and it didn't warn the
optimization system via the ``view_map`` attribute. optimization system via the ``view_map`` attribute.
For detailed documentation on the Exception, see :api:`BadViewMap`.
For detailed documentation on the ``view_map`` attribute, see :ref:`views`. For detailed documentation on the ``view_map`` attribute, see :ref:`views`.
...@@ -119,7 +114,6 @@ steps are ordered by ``id(object)`` somehow, such as via the default object ...@@ -119,7 +114,6 @@ steps are ordered by ``id(object)`` somehow, such as via the default object
hash function. A Stochastic optimization invalidates the pattern of work hash function. A Stochastic optimization invalidates the pattern of work
whereby we debug in DEBUG_MODE and then run the full-size jobs in FAST_RUN. whereby we debug in DEBUG_MODE and then run the full-size jobs in FAST_RUN.
For detailed documentation see :api:`StochasticOrder`.
...@@ -136,6 +130,5 @@ introduced into the computations. It indicates which Op created the first ...@@ -136,6 +130,5 @@ introduced into the computations. It indicates which Op created the first
NaN. These floating-point values can be allowed by passing the NaN. These floating-point values can be allowed by passing the
``check_isfinite=False`` argument to DebugMode. ``check_isfinite=False`` argument to DebugMode.
For detailed documentation see :api:`InvalidValueError`.
doc/tutorial/examples.txt
浏览文件 @ e789f49c
...@@ -22,7 +22,7 @@ the logistic curve, which is given by: ...@@ -22,7 +22,7 @@ the logistic curve, which is given by:
A plot of the logistic function, with x on the x-axis and s(x) on the A plot of the logistic function, with x on the x-axis and s(x) on the
y-axis. y-axis.
You want to compute the function :term:`elementwise` on matrices of You want to compute the function :ref:`elementwise <libdoc_tensor_elementwise>` on matrices of
doubles, which means that you want to apply this function to each doubles, which means that you want to apply this function to each
individual element of the matrix. individual element of the matrix.
...@@ -58,7 +58,7 @@ Computing more than one thing at the same time ...@@ -58,7 +58,7 @@ Computing more than one thing at the same time
============================================== ==============================================
Theano supports functions with multiple outputs. For example, we can Theano supports functions with multiple outputs. For example, we can
compute the :term:`elementwise` difference, absolute difference, and compute the :ref:`elementwise <libdoc_tensor_elementwise>` difference, absolute difference, and
squared difference between two matrices ``a`` and ``b`` at the same time: squared difference between two matrices ``a`` and ``b`` at the same time:
>>> a, b = T.dmatrices('a', 'b') >>> a, b = T.dmatrices('a', 'b')
...@@ -134,16 +134,17 @@ array([[ 0.25 , 0.19661193], ...@@ -134,16 +134,17 @@ array([[ 0.25 , 0.19661193],
The resulting function computes the gradient of its first argument The resulting function computes the gradient of its first argument
with respect to the second. In this way, Theano can be used for with respect to the second. In this way, Theano can be used for
`automatic differentiation`_. `automatic differentiation <http://en.wikipedia.org/wiki/Automatic_differentiation>`_.
.. note:: .. note::
The variable of ``T.grad`` has the same dimensions as the The second argument of ``T.grad`` can be a list, in which case the
second argument. This is exactly like the first derivative if the output is also a list. The order in both list is important, element
first argument is a scalar or a tensor of size 1 but not if it is *i* of the output list is the gradient of the first argument of
larger. For more information on the semantics when the first ``T.grad`` with respect to the *i*-th element of the list given as second argument.
argument has a larger size and details about the implementation, The first arguement of ``T.grad`` has to be a scalar (a tensor
see :api:`tensor.grad`. of size 1). For more information on the semantics of the arguments of
``T.grad`` and details about the implementation, see :ref:`this <libdoc_gradient>`.
Setting a default value for an argument Setting a default value for an argument
...@@ -291,8 +292,9 @@ the substitutions have to work in any order. ...@@ -291,8 +292,9 @@ the substitutions have to work in any order.
Mode Mode
==== ====
The ``mode`` parameter to :api:`theano.function` controls how the The ``mode`` parameter to :ref:`theano.function <libdoc_compile_function>`
inputs-to-outputs graph is transformed into a callable object. controls how the inputs-to-outputs graph is transformed into a callable
object.
Theano defines the following modes by name: Theano defines the following modes by name:
...@@ -304,15 +306,11 @@ Theano defines the following modes by name: ...@@ -304,15 +306,11 @@ Theano defines the following modes by name:
The default mode is typically ``FAST_RUN``, but it can be controlled via The default mode is typically ``FAST_RUN``, but it can be controlled via
the environment variable ``THEANO_DEFAULT_MODE``, which can in turn be the environment variable ``THEANO_DEFAULT_MODE``, which can in turn be
overridden by setting :api:`theano.compile.mode.default_mode` directly, overridden by setting `theano.compile.mode.default_mode` directly,
which can in turn be overridden by passing the keyword argument to which can in turn be overridden by passing the keyword argument to
:api:`theano.function`. :ref:`theano.function <libdoc_compile_function>`.
For a finer level of control over which optimizations are applied, and
whether C or python implementations are used, read
:api:`compile.mode.Mode`.
.. _automatic differentiation: http://en.wikipedia.org/wiki/Automatic_differentiation
doc/tutorial/index.txt
浏览文件 @ e789f49c
...@@ -10,7 +10,7 @@ Let's start an interactive session and import Theano. ...@@ -10,7 +10,7 @@ Let's start an interactive session and import Theano.
>>> from theano import * >>> from theano import *
Many of symbols you will need to use are in the ``tensor`` subpackage Many of symbols you will need to use are in the ``tensor`` subpackage
of theano. Let's import that subpackage under a handy name. I like of Theano. Let's import that subpackage under a handy name. I like
``T`` (and many tutorials use this convention). ``T`` (and many tutorials use this convention).
>>> import theano.tensor as T >>> import theano.tensor as T
......
doc/tutorial/numpy.txt
浏览文件 @ e789f49c
...@@ -8,10 +8,9 @@ NumPy refresher ...@@ -8,10 +8,9 @@ NumPy refresher
Here are some quick guides to NumPy: Here are some quick guides to NumPy:
* `Numpy quick guide for Matlab users <http://www.scipy.org/NumPy_for_Matlab_Users>`__ * `Numpy quick guide for Matlab users <http://www.scipy.org/NumPy_for_Matlab_Users>`__
* `More detailed table showing the NumPy equivalent of Matlab commands <http://www.scribd.com/doc/26685/Matlab-Python-and-R>`__ * `Numpy User Guide <http://docs.scipy.org/doc/numpy/user/index.html>`__
* `More detailed Numpy tutorial <http://www.scipy.org/Tentative_NumPy_Tutorial>`__
.. TODO [DefineBroadcasting Broadcasting]
.. Broadcastable - Implicitly assume that all previous entries are true.
.. [TODO: More doc, e.g. see _test_tensor.py] .. [TODO: More doc, e.g. see _test_tensor.py]
...@@ -20,8 +19,10 @@ Matrix conventions for machine learning ...@@ -20,8 +19,10 @@ Matrix conventions for machine learning
Rows are horizontal and columns are vertical. Rows are horizontal and columns are vertical.
Every row is an example. Therefore, inputs[10,5] is a matrix of 10 examples with 5 dimensions per. Every row is an example. Therefore, inputs[10,5] is a matrix of 10 examples
So to make a NN out of it, multiply by a weight matrix of size (5, #hid). where each example has dimension 5. If this would be the input of a
neural network then the weights from the input the the first hidden
layer would represent a matrix of size (5, #hid).
If I have an array: If I have an array:
...@@ -43,3 +44,22 @@ To access the entry in the 3rd row (row #2) and the 1st column (column #0): ...@@ -43,3 +44,22 @@ To access the entry in the 3rd row (row #2) and the 1st column (column #0):
To remember this, keep in mind that we read left-to-right, top-to-bottom, To remember this, keep in mind that we read left-to-right, top-to-bottom,
so each thing that is contiguous is a row. That is, there are 3 rows so each thing that is contiguous is a row. That is, there are 3 rows
and 2 columns. and 2 columns.
Broadcasting
============
Numpy does *broadcasting* of arrays of different shapes during
arithmetic operations. What this means in general is that the smaller
array is *broadcasted* across the larger array so that they have
compatible shapes. The example below shows an instance of
*broadcastaing*:
>>> a = numpy.asarray([1.0, 2.0, 3.0])
>>> b = 2.0
>>> a * b
array([2., 4., 6.])
The smaller array ``b`` in this case is *broadcasted* to the same size
as ``a`` during the multiplication. This trick is often useful in
simplifying how expression are written. More details about *broadcasting*
can be found at `numpy user guide <http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html>`__.
doc/tutorial/tools.txt
浏览文件 @ e789f49c
...@@ -28,7 +28,7 @@ Predefined types ...@@ -28,7 +28,7 @@ Predefined types
---------------- ----------------
Predefined types are Predefined types are
located in the :api:`theano.tensor` package. The name of the types follow located in the :ref:`theano.tensor <libdoc_tensor>` package. The name of the types follow
a recipe: a recipe:
``<dtype><dimensionality>`` ``<dtype><dimensionality>``
...@@ -48,26 +48,26 @@ d double floating point 64 ...@@ -48,26 +48,26 @@ d double floating point 64
Dimensionality is one of: Dimensionality is one of:
====== ====== ========================================== ============================================= ====== ====== ======================================================== ===========================================================
code shape Rows :term:`broadcastable <broadcasting>`? Columns :term:`broadcastable <broadcasting>`? code shape Rows :ref:`broadcastable <libdoc_tensor_broadcastable>`? Columns :ref:`broadcastable <libdoc_tensor_broadcastable>`?
====== ====== ========================================== ============================================= ====== ====== ======================================================== ===========================================================
scalar [] Yes Yes scalar [] Yes Yes
vector [n] Yes N/A (vectors are used like row vectors) vector [n] Yes N/A (vectors are used like row vectors)
row [1, n] Yes No row [1, n] Yes No
col [m, 1] No Yes col [m, 1] No Yes
matrix [m, n] No No matrix [m, n] No No
====== ====== ========================================== ============================================= ====== ====== ======================================================== ============================================================
So, if you want a row of 32-bit floats, it is available So, if you want a row of 32-bit floats, it is available
as :api:`theano.tensor.frow <theano.tensor.basic.frow>`. as :ref:`theano.tensor.frow <libdoc_tensor_type>`.
If you want a matrix of unsigned 32-bit integers it is available as If you want a matrix of unsigned 32-bit integers it is available as
:api:`theano.tensor.imatrix <theano.tensor.basic.imatrix>`. :ref:`theano.tensor.imatrix <libdoc_tensor_type>`.
Each of the types described above can be constructed by two methods: Each of the types described above can be constructed by two methods:
a singular version (e.g., :api:`dmatrix <theano.tensor.basic.dmatrix>`) a singular version (e.g., :ref:`dmatrix <libdoc_tensor_creation>`)
and a plural version (:api:`dmatrices <theano.tensor.dmatrices>`). and a plural version (:ref:`dmatrices <libdoc_tensor_creation>`).
When called, the singular version takes a single When called, the singular version takes a single
argument which is the name of the :term:`Variable` we want to make and it argument which is the name of the *Variable* we want to make and it
makes a single Variable of that type. The plural version can either take makes a single Variable of that type. The plural version can either take
an integer or several strings. If an integer is provided, the method an integer or several strings. If an integer is provided, the method
will return that many Variables and if strings are provided, it will will return that many Variables and if strings are provided, it will
...@@ -91,7 +91,7 @@ Custom tensor types ...@@ -91,7 +91,7 @@ Custom tensor types
If you wish to use a type of tensor which is not already available here If you wish to use a type of tensor which is not already available here
(for example, a 3D tensor) you can build an appropriate type using (for example, a 3D tensor) you can build an appropriate type using
:api:`theano.tensor.TensorType <theano.tensor.basic.TensorType>`. :ref:`theano.tensor.TensorType <libdoc_tensor_type>`.
The first argument you pass is the `dtype` and the second is the The first argument you pass is the `dtype` and the second is the
`broadcastable pattern`. `broadcastable pattern`.
...@@ -116,10 +116,10 @@ complex128 complex 128 (two float64) ...@@ -116,10 +116,10 @@ complex128 complex 128 (two float64)
.. note:: .. note::
Even though :api:`theano.tensor` does not define any type Even though :ref:`theano.tensor <libdoc_tensor>` does not define any type
using ``complex`` dtypes (``complex64`` or ``complex128``), using ``complex`` dtypes (``complex64`` or ``complex128``),
you can define them explicitly with you can define them explicitly with
:api:`TensorType <theano.tensor.basic.TensorType>` (see example :ref:`TensorType <libdoc_tensor_type>` (see example
below). However, few operations are fully supported for complex below). However, few operations are fully supported for complex
types: as of version 0.1, only elementary operations (``+-*/``) types: as of version 0.1, only elementary operations (``+-*/``)
have C implementations. Additionally, complex types have received have C implementations. Additionally, complex types have received
...@@ -128,8 +128,7 @@ complex128 complex 128 (two float64) ...@@ -128,8 +128,7 @@ complex128 complex 128 (two float64)
The broadcastable pattern indicates both the number of dimensions and The broadcastable pattern indicates both the number of dimensions and
whether a particular dimension must have length 1. whether a particular dimension must have length 1.
Here is a table mapping the :term:`broadcastable Here is a table mapping the :ref:`broadcastable <libdoc_tensor_broadcastable>` pattern to what kind of tensor it encodes:
<broadcasting>` pattern to what kind of tensor it encodes:
===================== ================================= ===================== =================================
pattern interpretation pattern interpretation
......
theano/sandbox/scan.py
浏览文件 @ e789f49c
"""Provide Scan and related functions """Provide Scan and related functions
Scanning a function over sequential input(s) producing sequential output(s). Scanning a function over sequential input(s) producing sequential output(s).
Scanning is a general form of recurrence, which can be used for looping. Scanning is a general form of recurrence, which can be used for looping.
The idea is that you 'scan' a function along some input sequence, producing an output at each The idea is that you 'scan' a function along some input sequence, producing
time-step that can be seen (but not modified) by the function at the next time-step. an output at each time-step that can be seen (but not modified) by the
(Technically, the function can see the previous K time-steps.) function at the next time-step. (Technically, the function can see the
previous K time-steps.)
So for example, ``sum()`` could be computed by scanning the ``z+x_i`` function over a list, So for example, ``sum()`` could be computed by scanning the ``z+x_i``
given an initial state of ``z=0``. function over a list, given an initial state of ``z=0``.
Special cases: Special cases:
- A ``reduce()`` operation can be performed by returning only the last output of a scan. - A ``reduce()`` operation can be performed by returning only the last
output of a scan.
- A ``map()`` operation can be performed by applying a function that ignores each previous - A ``map()`` operation can be performed by applying a function that
output. ignores each previous output.
Often a for loop can be expressed as a scan() operation, and scan is the closest that theano Often a for loop can be expressed as a scan() operation, and scan is the
comes to looping. closest that theano comes to looping.
This module provides scanning functionality with the `Scan` Op. This module provides scanning functionality with the `Scan` Op.
""" """
__docformat__ = 'restructedtext en' __docformat__ = 'restructedtext en'
import traceback
import numpy import numpy
import theano import theano
import theano.compile
from theano.tensor import opt from theano.tensor import opt
from theano import gof from theano import gof
from theano.compile import optdb from theano.compile import optdb
''' # Logging function for sending warning or info
TODO : move out of sandbox ! import logging
''' _logger = logging.getLogger('theano.scan')
def warning(*msg):
_logger.warning('WARNING theano.scan: '+' '.join(msg))
def info(*msg):
_logger.info('INFO theano.scan: '+' '.join(msg))
# Hashing a list; list used by scan are list of numbers, therefore a list
# can be hashed by hashing all elements in the list
def hash_list(list):
hash_value = 0
for v in list:
hash_value ^= v
return hash_value
# Hashing a dictionary; the dictionary used by scan has as keys numbers and
# as values either numbers or list of numbers
def hash_dict(dictionary):
hash_value = 0
for k,v in dictionary,iteritems():
# hash key
hash_value ^= k
if type(v) in (list,tuple):
hash_value ^= hash_list(v)
else:
hash_value ^= v
return hash_value
class Scan(theano.Op):
"""Scan a function `fn` over several inputs producing several outputs
This Op implements a generalization of scan in which `fn` may consult several previous def scan(fn, sequnces, non_sequences, seed_values, inplace_map={},
outputs from the past, from positions (taps) relative to the current time. The number of sequences_taps={}, outputs_taps = {},
taps (T_j) to use for each output (y_j) must be provided when creating a Scan Op. len = theano.tensor.zero(), force_gradient = False,
truncate_gradient = -1, go_backwards = False, mode = 'FAST_RUN'):
'''The function creates a more intuitive interface to the scan op.
Apply Inputs: This function first creates a scan op object, and afterwards applies it
to the input data. The scan operation iterates over X sequences producing
Y outputs. The function that is applied recursively may consult several
previous outputs from the past as well as past values and future values
of the input. You can see it as havin the inputs :
X sequence inputs x_1, x_2, ... x_X X sequences inptus x_1, x_2, .. x_X
Y initial states (u_1, u_2, ... u_Y) for our outputs. Each must have appropriate length Y seeds/initial values ( u_1, u_2, .. u_Y) for the outputs
(T_1, T_2, ..., T_Y).
W other inputs w_1, w_2, ... w_W W non sequences inputs w_1, w_2, .. w_W
Apply Outputs: Outputs :
Y sequence outputs y_1, y_2, ... y_Y Y sequence outputs y_1, y_2, .. y_Y
Each output y_j is computed one time-step at a time according to the formula: Each otuput y_j computed one time step at a time according to the
formula:
.. code-block:: python .. code-block:: python
(y_1[t], y_2[t],.., y_Y[t]) = fn( (y_1[t], y_2[t], .. y_Y[t]) = f(
x_1[t], x_2[t], ... x_X[t], # X current input values x_1[t-K_1],.. x_1[t],x_1[t+1],.. x_1[t+L_1], # x_1 past and future
y_1(t-1), y_1(t-2), .., y_1(t-T_1), # T_1 previous outputs for y_1 #values
y_2(t-1), y_2(t-2), ..., y_2(t-T_2), # T_2 previous outputs for y_2 x_2[t-K-2],.. x_2[t],x_2[t+1],.. x_2[t+L_2], # x_2 past and future
..., # ... # values
y_Y(t-1), y_Y(t-2), ..., y_Y(t-T_Y), # T_Y previous outputs for y_Y ... # ...
w_1, w_2,..., w_W) # W 'timeless' inputs y_1[t-1], y_1[t-2], .. y[t - T_1], # past values of y_1
y_2[t-1], y_2[t-2], .. y[t - T_2],, # past values of y_2
...
w_1, w_2, .., w_W) # 'timeless' inputs
:param fn: fn is a lambda expression or a function that given a list of
symbolic inputs returns the update list and symbolic outputs list of the
function that shall be applied recursively.
:param sequences:list of sequences over which the scan op should iterate;
sequnces length should also cover past and future taps; for example if
you also use for a sequence the past tap -3 and future tap +4, to total
length should be n+7, where first 3 values of sequence are those
corresponding to -3 -2 -1 and the last 4 values correspond to n+1 n+2
n+3 and n+4
:param non_sequences: list of inputs over which it shouldn't iterate
:param seed_values: seeds (initial values) of the outputs; if past taps
are this seeds should contain enough values to cover this past values;
note that index 0 of a seed belongs to the largest past tap
:param inplace_map: a dictionary telling which output should be
computed in place of which input sequence ; input sequence has to be
of the same shape as the output
:param sequence_taps: a dictionary telling for each sequence what past
and future taps it should use; past values should be negative, future
taps positives; by default 0 is added in this dictionary (current value)
if nothing is provided
:param outputs_taps: a dictionary telling for each output what past
taps it should use (negative values); by default -1 is added to this
dictionary if nothing is provided
:param len: a value (or theano scalar) describing for how many steps
the scan should iterate; 0 means that it should iterate over the entire
length of the input sequence(s)
:param force_gradient: a flag telling scan op that the gradient can be
computed even though inplace or updates are used - use this on your own
risk
:param truncate_gradient: tells for how many steps should scan go
back in time on the backward pass of backpropagation through time
:param go_backwards: a flag indicating if scan should iterate back from
the end of the sequence to the begining (if it is true) or from 0 to
the end
:param mode: indicates the mode that should be used to compile the
function that will be applied recursively
'''
# check if inputs are just single variables instead of lists
if not (type(sequences) in (list, tuple)):
seqs = [sequences]
elif seqs = sequences
So `fn` must accept X + T_1 + T_2 + ... + T_Y + W arguments. if not type(seed_values) in (list,tuple)):
seeds = [seed_values]
elif
seeds = seed_values
There are two high-level methods (`symbolic`, `compiled`) for creating a Scan Op besides if not (type(non_sequences) in (list,tuple)):
the low-level `__init__` constructor. ***Why would you call them?*** non_seqs = [non_sequences]
elif
non_seqs = non_sequences
When applying a Scan Op to theano Variables, the order of arguments is very important! When
using the full flexibility of Scan there can be a lot of arguments, but it is essential to
put them in the following order:
1. "Ignored inputs" (x_i with i < n_inplace_ignore) that will be overwritten by an inplace scan.
2. Inputs that will be overwritten by an inplace scan (x_i with i < n_inplace) # compute number of sequences and number of seeds
n_seqs = len(seqs)
3. Remaining Inputs (x_i with i >= n_inplace) # see if there are outputs that do not feed anything back to the function
# applied recursively
outs_tapkeys = outputs_taps.keys()
for k in outs_tapkeys.sort():
if outputs_taps[k] == []
# add empty lists where you have outputs that do not have past
# values
seeds = seeds[:k] + [[]] + seeds[k:]
3. Output states (u_j) corresponding to the outputs that are computed inplace (j < n_seeds = len(seeds)
n_inplace)
4. Remaining output states not given in 3 (u_j with j >= n_inplace) # update sequences_taps[idx] to contain 0 if it is not defined
for i in xrange(n_seqs):
if not sequences_taps.has_key(i):
sequences_taps.update({i:[0]})
# if input sequence is not actually used by the recursive function
elif sequences_taps[i] == []:
sequences_taps.__delitem__(i)
elif not (sequences_taps[i] in (list,tuple)):
sequences_taps[i] = [sequences_taps[i]]
5. Other inputs (w_1, w_2, ... w_W) # update outputs_taps[idx] to contain -1 if it is not defined
for i in xrange(n_seeds):
if not outputs_taps.has_key(i):
outputs_taps.update({i:-1})
# if output sequence is not actually used as input to the recursive
# function
elif outputs_taps[i] == []:
outputs_taps.__delitem__(i)
elif not(outputs_taps[i] in (list,tuple)):
outputs_taps[i] = [outputs_taps[i]]
Inplace Operation # create theano inputs for the recursive function
================= args = []
for (i,seq) in enumerate(seqs):
if sequences_taps.has_key(i):
for k in len(sequences_taps[i]):
args += [seq[0].type() ]
for (i,seed) in enumerate(seeds):
if outputs_taps.has_key(i):
for k in len(outputs_taps[i]):
args += [seed[0].type() ]
The Scan Op supports computing some (`n_inplace`) of the outputs y_j using the memory from args += non_seqs
corresponding inputs x_j. next_outs, updates = fn(*args)
It is not possible to indicate precisely which outputs overwrite which inputs, but without
loss of generality we assume that each of the first `n_inplace` outputs (y_j) overwrites
the corresponding input (x_j).
Note that using inplace computations destroys information, and may make it # Create the Scan op object
impossible to compute the gradient. local_op = Scan( (args,next_outs, updates), n_seqs,n_seeds,inplace_map,
As long as the function 'fn' does not update any of the other sequences_taps, outputs_taps, force_gradient, truncate_gradient,
parameters (w_1,..) a gradient of this operation is supported. go_backwards, mode)
***Who will care about this? Someone just using the Op? Someone writing an inplace
optimization?***
Ignored Inputs # Call the object on the input sequences, seeds, and non sequences
============== return local_op( *( [thenao.tensor.as_tensor(len)] \
+ seqs \
+ seeds \
+ non_seqs))
**** Behaviour? Rationale? Use case?
"""
@classmethod
def symbolic(cls,(in_args,out_args), n_ins, n_outs,\
n_inplace=0, n_inplace_ignore=0, taps={},
mode = 'FAST_RUN'):
# if in_args is not a list assume it is just a variable and
# convert it to a list (if this is neither the case the code will
# raise an error somewhere else !)
if not( type(in_args) in (list,tuple)):
in_args = [in_args]
# if out_args is not a list assume it is just a variable and
# convert it to a list
if not (type(out_args) in (list,tuple)):
out_args = [out_args]
# Create fn ''' The class implementing the scan op
my_fn = theano.compile.sandbox.pfunc(in_args, out_args, mode = mode)
# Create gradient function The actual class. I would not recommend using it directly unless you really
gy_next = [out_args[0].type()] know what you are doing'
g_inputs = theano.tensor.grad(out_args[0],in_args,g_cost=gy_next[-1]) '''
for y_next in out_args[1:] : class Scan(theano.Op):
gy_next +=[y_next.type()] def __init__(self,(inputs, outputs, updates),n_seqs, n_seeds,
g_ls = theano.tensor.grad(y_next,in_args,g_cost=gy_next[-1]) inplace_map={}, seqs_taps={}, outs_taps={},
for i in xrange(len(in_args)): force_gradient = False, truncate_gradient = -1,
g_inputs[i] += g_ls[i] go_backwards = False, inplace=False):
g_fn=theano.compile.sandbox.pfunc(gy_next+in_args,g_inputs, '''
mode=mode) :param inputs: list of symbolic inputs of the function that will
be applied recursively
:param outputs: list of symbolic outputs for the function applied
recursively
:param updates: list of updates for the function applied recursively
:param n_seqs: number of sequences in the input over which it needs
to iterate
:param n_seeds: number of outputs (same as the number of seeds)
:param inplace_map: dictionary discribing which output should be
computed inplace of which input
return cls(my_fn, g_fn, n_ins, n_outs,\ :param seqs_taps: dictionary discribing which past and future taps
n_inplace,n_inplace_ignore, taps) of the input sequences are used by the recursive function
@classmethod :param outs_taps: dictionary discribing which past taps of the
def compiled(cls,fn,n_ins, n_outs,\ outputs the recursive function is using
n_inplace=0, n_inplace_ignore=0, taps={}):
"""Return a Scan instance that will scan the callable `fn` over `n_ins` inputs and
`n_outs` outputs.
:param force_gradient: a flag indicating if the gradient is still
computable even though inplace operation or updates are used
""" :param truncate_gradient: if different from -1 it tells after how
return cls(fn, None, n_ins, n_outs, \ many steps in the backward pass of BPTT
n_inplace, n_inplace_ignore, taps= taps) '''
# check inplace map
for _out,_in in inplace_map.iteritems():
if _out > n_seeds:
raise ValueError(('Inplace map reffers to an unexisting'\
'output %d')% _out)
if _in > n_seqs:
raise ValueError(('Inplace map reffers to an unexisting'\
'input sequence %d')%_in)
if (_in >= 0) and (min(seqs_taps[_in]) < 0):
raise ValueError(('Input sequence %d uses past values that '\
'will be overwritten by inplace operation')%_in)
def __init__(self,fn,grad_fn,n_ins,n_outs,
n_inplace=0, n_inplace_ignore=0,
taps={}, inplace=False):
"""Create an instance of the scan class
To use Scan, first you need to create it specifying the number of inputs, outputs, #check sequences past taps
inplace outputs (see notes below), and inputs to be ignored, a dictionary describing for k,v in seqs_taps.map_iteritems():
the time taps used, the function that will be applied recursively and optionally, the if k > n_seqs:
gradient function (or a symbolic definition of the function and the op will compute the raise ValueError(('Sequences past taps dictionary reffers to '
gradient on its own). Secondly you just call the op with a list of parameters. 'an unexisting sequence %d')%k)
:param fn: compiled function that takes you from time step t-1 to t #check outputs past taps
for k,v in outs_taps.map_iteritems():
if k > n_seeds:
raise ValueError(('Sequences past taps dictionary reffers to '
'an unexisting sequence %d')%k)
if max(v) > -1:
raise ValueError(('Can not require future value %d of output'
'%d')%(k,max(v)))
:param grad_fn: gradient of the function applied recursevly
:param n_ins: number of inputs; in the list of arguments
they start from 0 to 'n_ins'
:param n_outs: number of outputs; in the list of arguments you
need to give the initial state of each outputs, this will be from
'n_ins' to 'n_outs'; each initial state should be a matrix where
the first dimension is time and should be sufficiently large to
cover the time taps. The matrix for an initial state should be
ordered such that if you use k delays, index 0 of matrix stands for
the value at time -k, index 1 for value at time 1-k, index 2 for
value at time 2-k and index k-1 for value at time -1
:param n_inplace: indicates the number of outputs that should be
computed inplace; in the list of arguments there will be the first
'n_inplace' outputs in place of the first 'n_inplace' inputs
:param n_inplace_ignore: indicates the number of inputs that are
given just to be replaced by the inplace computation and which
should not be given as arguments to the function applied
recursevly
:param taps: a dictionary which for each output index gives
a list of what taps it uses; a tap is given as an int,
where x stands for output(t - x); note that a past trace of 1 makes
no sense, since you get that by default
:param inplace: is used by the optimizer that allows the inplace
computation
"""
if n_ins < 1:
raise ValueError('Scan should iterate over at least on one input')
if n_outs <1:
raise ValueError('Scan should have at least one output')
if (n_inplace > n_ins):
raise ValueError('Number of inplace outputs should be smaller than '
'the number of inputs.')
if (n_inplace < 0):
raise ValueError('Number of inplace outputs should be larger '
'or equal to 0')
if (n_inplace_ignore > n_inplace):
raise ValueError('Number of inputs to ignore should not be '\
'larger than number of inplace outputs')
if (n_inplace_ignore < 0):
raise ValueError('n_inplace_ignore should be non-negative')
self.destroy_map = {} self.destroy_map = {}
if inplace: if inplace:
for i in xrange(n_inplace): self.destroy_map = inplace_map
self.destroy_map.update( {i:[i]} )
self.seqs_taps = seqs_taps
for (k,v) in taps.iteritems(): self.outs_taps = outs_taps
if k < 0 or k > n_outs: self.n_seqs = n_seqs
raise ValueError('Taps dictionary contains wrong key!') self.n_seeds = n_seeds
for vi in v: self.n_args = n_seqs+n_seeds+1
# why is it illegal to specify vi < 2? self.inplace_map = inplace_map
# what is special about vi == 1?
#
# Would it be simpler to just leave v alone if it is non-empty (checking that
# all vi are >=1) and set v = [1] for all missing output keys?
if vi < 2:
raise ValueError('Taps dictionary contains wrong values!')
self.taps = taps
self.n_ins = n_ins
self.n_outs = n_outs
self.n_inplace = n_inplace
self.inplace = inplace self.inplace = inplace
self.n_inplace_ignore = n_inplace_ignore self.inputs = inputs
self.fn = fn self.outputs = outputs
self.grad_fn = grad_fn self.updates = updates
self.force_gradient = force_gradient
self.truncate_gradient = truncate_gradient
self.go_backwards = go_backwards
self.fn = theano.function(inputs,outputs, \
updates = updates, mode = mode)
def make_node(self, *inputs): g_y = [outputs[0].type()]
"""Create an node for the Scan operation g_args = theano.tensor.grad(outputs[0],inputs, g_cost = g_y[-1])
# for all outputs compute gradients and then sum them up
for y in outputs[1:]:
g_y += [y.type()]
g_args_y = theano.tensor.grad(y,inputs, g_cost=g_y[-1])
for i in xrange(len(g_args)):
g_args[i] += g_args_y[i]
:param inputs: list of inputs for the operations; they should be
at least 'self.n_ins'+'self.n_outs' arguments; first 'self.n_inplace'
are inputs that are replaced inplace, followed by oter inputs up
to 'self.n_ins'; next 'self.n_outs' are ouputs followed by other
arguments that will be given to the function applied recursevly
"""
self.g_ins = g_y+inputs
self.g_outs = g_args
def make_node(self,*inputs):
n_args = len(inputs) n_args = len(inputs)
min_n_args = self.n_ins+self.n_outs if n_args < self.n_args :
if n_args < min_n_args: err = 'There should be at least '+str(self.n_args)+ 'arguments'
err = 'There should be at least '+str(min_n_args)+ 'arguments'
raise ValueError(err) raise ValueError(err)
# Create list of output datatypes # Create list of output datatypes
out_types = [] out_types = []
for i in xrange(self.n_ins,self.n_ins+self.n_outs): for i in xrange(self.n_seqs+1, self.n_seqs+self.n_seeds+1):
out_types += [theano.tensor.Tensor(dtype=inputs[i].dtype,\ out_types += [theano.tensor.Tensor(dtype=inputs[i].dtype,\
broadcastable=(False,)+inputs[i].broadcastable[1:])()] broadcastable=(False,)+inputs[i].broadcastable[1:])()]
return theano.Apply(self,inputs, out_types) return theano.Apply(self,inputs, out_types)
def __eq__(self,other): def __eq__(self,other):
rval = type(self) == type(other) rval = type(self) == type(other)
if rval: if rval:
rval = (self.fn is other.fn) and \ rval = (self.inputs == other.inputs) and \
(self.grad_fn is other.grad_fn) and \ (self.outputs == other.outputs) and \
(self.n_ins == other.n_ins) and \ (self.updates == other.updates) and \
(self.n_outs == other.n_outs) and \ (self.g_ins == other.g_ins) and \
(self.n_inplace == other.n_inplace) and \ (self.g_outs == other.g_outs) and \
(self.n_inplace_ignore == other.n_inplace_ignore) and\ (self.seqs_taps == other.seqs_taps) and \
(self.outs_taps == other.outs_taps) and \
(self.inplace_map == other.inplace_map) and \
(self.n_seqs == other.n_seqs) and\
(self.inplace == other.inplace) and\ (self.inplace == other.inplace) and\
(self.taps == other.taps) (self.go_backwards == other.go_backwards) and\
(self.truncate_gradient == other.truncate_gradient) and\
(self.force_gradient = other.force_gradient) and\
(self.n_seeds == other.n_seeds) and\
(self.n_args == other.n_args)
return rval return rval
def __hash__(self): def __hash__(self):
# hash the taps dictionary
taps_hash = 0
for k,v in self.taps.iteritems():
taps_hash ^= k
for vi in v :
taps_hash ^= vi
return hash(type(self)) ^ \ return hash(type(self)) ^ \
hash(self.fn) ^ \ hash(self.n_seqs) ^ \
hash(self.grad_fn) ^ \ hash(self.n_seeds) ^ \
hash(self.n_ins) ^ \ hash(self.force_gradient) ^\
hash(self.n_outs) ^ \
hash(self.n_inplace) ^ \
hash(self.n_inplace_ignore) ^\
hash(self.inplace) ^\ hash(self.inplace) ^\
taps_hash hash(self.go_backwards) ^\
hash(self.truncate_gradient) ^\
hash(self.n_args) ^ \
hash_list(self.outputs) ^ \
hash_list(self.inputs) ^ \
hash_list(g_ins) ^ \
hash_list(h_outs) ^ \
hash_dict(self.seqs_taps) ^\
hash_dict(self.outs_taps) ^\
hash_dict(self.inplace_map) ^\
hash_dict(self.updates)
def grad(self, inputs, g_outs):
if self.grad_fn == None: def perform(self,node,args, outs):
print 'Warning! no gradient for the recursive function was given'
return [None for i in inputs]
else:
y = self(*inputs)
if not( type(y) in (list,tuple)):
y = [y]
for i in xrange(len(y)): n_steps = 0
if g_outs[i] == None: if (self.n_seqs ==0 ) and (args[0] == 0)
g_outs[i] = theano.tensor.zeros_like(y[i]) raise ValueError('Scan does not know over how many steps it '
'should iterate! No input sequence or number of steps to '
'iterate given !')
if (args[0] != 0):
n_steps = args[0]
for i in xrange(self.n_seqs):
if self.seqs_taps.has_key(i):
# compute actual length of the sequence ( we need to see what
# past taps this sequence has, and leave room for them
seq_len = args[i+1].shape[0] + min(self.seqs_taps[i+1])
if self.seqs_taps[i+1][2] > 0:
# using future values, so need to end the sequence earlier
seq_len -= self.seqs_taps[i+1][2]
if n_steps == 0 :
# length of the sequences, leaving room for the largest
n_steps = seq_len
if seq_len != n_steps :
warning(('Input sequence %d has a shorter length then the '
'expected number of steps %d')%(i,n_steps))
n_steps = min(seq_len,n_steps)
# check if we deal with an inplace operation
inplace_map = self.inplace_map
if not self.inplace: #if it was not optimized to work inplace
inplace_map = {}
# Construct my gradient class:
gradScan = ScanGrad(self.grad_fn,
self.n_ins- self.n_inplace_ignore, self.n_outs,
self.taps)
# check lengths of seeds
for i in xrange(self.n_seqs+1, \
self.n_seqs+self.n_seeds+1):
if self.outs_taps.has_key(i-self.n_seqs-1):
req_size = abs(min(self.outs_taps[i-self.n_seqs-1]))-1
if args[i].shape[0] < req_size:
warning(('Initial state for output %d has fewer values then '
'required by the maximal past value %d. Scan will use 0s'
' for missing values')%(i-self.n_iterable-1,req_size))
args = g_outs + y + \ self.n_steps = n_steps
inputs[self.n_inplace_ignore:] y = self.scan(self.fn, args[1:],self.n_seqs, self.n_seeds,
self.seqs_taps, self.outs_taps, n_steps, self.go_backwards,
inplace_map)
grads = gradScan(*args)
rval = [None for i in inputs[:self.n_inplace_ignore]]+grads
return rval
# write to storage
for i in xrange(self.n_seeds):
outs[i][0]=y[i]
def perform(self,node,args, outs):
# find number of timesteps, note that a precondition is to have
# atleast one input to iterate over
n_steps = len(args[0])
# check if we deal with a inplace operation def scan(fn, args, n_seqs, n_seeds, seqs_taps, outs_taps, n_steps,
n_inplace = self.n_inplace go_backwards, inplace_map):
n_inplace_ignore = self.n_inplace_ignore y = []
if not self.inplace: #if it was not optimized to work inplace for i in xrange(self.n_seeds):
n_inplace = 0 if inplace_map.has_key(i) and (inplace_map[i] >= 0):
y += [args[inplace_map[i]]]
else:
y_shape = (n_steps,)+args[i+self.n_seqs].shape[1:]
y += [numpy.empty(y_shape,
dtype=args[i+self.n_seqs].dtype)]
#iterate
if go_backwards:
the_range = xrange(n_steps-1,-1,-1)
else:
the_range = xrange(n_steps)
seqs_mins = {}
for j in xrange(self.n_seqs):
if seqs_taps.has_key(j):
seqs_mins.update({j: min(seqs_taps[j])})
# check lengths of inputs outs_mins = {}
for i in xrange(self.n_ins): seed_size = {}
if args[i].shape[0] != n_steps: for j in xrange(self.n_seeds):
raise ValueError('All inputs should have n_steps length!') if outs_taps.has_key(j):
outs_mins.update({j: min(outs_taps[j])})
seed_size.update({j: args[n_seqs+j].shape[0]})
# check lengths of initial states
for i in xrange(self.n_ins, self.n_ins+self.n_outs):
req_size = 1
if self.taps.has_key(i- self.n_ins):
req_size = max(self.taps[i-self.n_ins])
if len(args[i].shape) == 0:
raise ValueError('Wrong initial state! ')
if args[i].shape[0] < req_size:
raise ValueError('Wrong initial state! ')
# allocate space for the outputs for i in the_range:
y = []
# inplace outputs
for i in xrange(n_inplace):
y += [args[i]]
# add outputs
for i in xrange(self.n_ins+n_inplace,self.n_ins+self.n_outs):
y_shape = (n_steps,)+args[i].shape[1:]
y += [numpy.empty(y_shape, dtype = args[i].dtype)]
# iterate
for i in xrange(n_steps):
fn_args = [] fn_args = []
# get a time slice of inputs
for j in xrange(n_inplace_ignore, self.n_ins):
fn_args += [args[j][i]]
# get past values of outputs (t-1 + taps) # sequences over which scan iterates
for j in xrange(self.n_outs): for j in xrange(self.n_seqs):
# get list of taps if seqs_taps.has_key(j):
ls_taps = [1] ls_taps = seqs_taps[j]
if self.taps.has_key(j): min_tap = seqs_mins[j]
ls_taps += self.taps[j] for tap_value in ls_taps:
maxVal = max(ls_taps) k = i - min_tap + tap_value
fn_args += [args[j][k]]
# seeds or past values of outputs
for j in xrange(self.n_seeds):
if outs_taps.has_key(j):
ls_taps = outs_taps[j]
min_tap = outs_mins[j]
seed_sz = seed_size[j]
for tap_value in ls_taps: for tap_value in ls_taps:
if i - tap_value < 0: if i + tap_value < 0:
fn_args += [args[j+self.n_ins][maxVal-tap_value+i]] k = i + seed_sz + tap_value
if k < 0
# past value not provided.. issue a warning and use 0s
fn_args += [numpy.zeros(args[j][0].shape)]
warning('Past value %d for output %d not given in seeds' %
(j,tap_value))
else: else:
fn_args += [y[j][i-tap_value]] fn_args += [args[j][k]]
else:
fn_args += [y[j][i + tap_value]]
# get the none iterable parameters # get the non-iterable sequences
fn_args += list(args[(self.n_ins+self.n_outs):]) fn_args += list(args[(self.n_seqs+self.n_seedss):]
# compute output # compute output
something = self.fn(*fn_args) something = fn(*fn_args)
# update y and inplace outputs #update outputs
for j in xrange(self.n_outs): for j in xrange(self.n_seeds):
y[j][i] = something[j] y[j][i] = something[j]
return y
# write to storage
for i in xrange(self.n_outs): def grad(self, args, g_outs):
outs[i][0]=y[i] if (not self.force_gradient) and \
((self.updates.keys() != []) or (self.inplace_map.keys() != [])):
warning('Can not compute gradients if inplace or updates ' \
'are used. Use force_gradient if you know for sure '\
'that the gradient can be computed automatically.')
return [None for i in inputs]
else:
# forward pass
y = self(*args)
if not( type(y) in (list,tuple)):
y = [y]
# backwards pass
for i in xrange(len(y)):
if g_outs[i] == None:
g_outs[i] = theano.tensor.zeros_like(y[i])
g_args = [self.n_steps]+g_outs + y
# check if go_backwards is true
if self.go_backwards:
for seq in args[1:self.n_seqs]:
g_args += [seq[::-1]]
else:
g_args += args[1:self.n_seqs]
g_args += args[1+self.n_seqs: ]
g_scan = ScanGrad((self.g_ins,self.g_outs), self.n_seqs, \
self.n_seeds,self.seqs_taps, self.outs_taps,
self.truncate_gradient)
return g_scan(g_args)
@gof.local_optimizer([None]) @gof.local_optimizer([None])
def scan_make_inplace(node): def scan_make_inplace(node):
op = node.op op = node.op
if isinstance(op, Scan) and (not op.inplace) and (op.n_inplace>0): if isinstance(op, Scan) and (not op.inplace) \
return Scan(op.fn, op.grad_fn, op.n_ins,\ and (op.inplace_map.keys() != []):
op.n_outs, op.n_inplace, op.n_inplace_ignore,\ return Scan((op.inputs, op.outputs, op.updates), op.n_seqs, \
op.taps,inplace=True\ op.n_seeds, op.inplace_map, op.seqs_taps, op.outs_taps, \
op.force_gradient, op.truncate_gradient, \
op.go_backwards, inplace=True \
).make_node(*node.inputs).outputs ).make_node(*node.inputs).outputs
return False return False
optdb.register('scan_make_inplace', opt.in2out(scan_make_inplace,\ optdb.register('scan_make_inplace', opt.in2out(scan_make_inplace,\
ignore_newtrees=True), 75, 'fast_run', 'inplace') ignore_newtrees=True), 75, 'fast_run', 'inplace')
...@@ -428,144 +587,160 @@ optdb.register('scan_make_inplace', opt.in2out(scan_make_inplace,\ ...@@ -428,144 +587,160 @@ optdb.register('scan_make_inplace', opt.in2out(scan_make_inplace,\
class ScanGrad(theano.Op): class ScanGrad(theano.Op):
"""Gradient Op for Scan""" """Gradient Op for Scan"""
def __init__(self,(g_ins, g_outs) , n_seqs, n_outs,
def __init__(self, grad_fn, n_ins, n_outs, seqs_taps = {}, outs_taps= {}, truncate_gradient = -1):
taps = {},inplace=False): self.grad_fn = theano.function(g_ins, g_outs)
self.grad_fn = grad_fn self.inputs = g_ins
self.n_ins = n_ins # number of inputs of Scan op not of Grad Scan !! self.outputs = g_outs
self.n_outs = n_outs # number of outs of Scan op not of Grad Scan !! self.n_seqs = n_seqs
self.inplace = inplace self.truncate_gradient = truncate_gradient
self.taps = taps self.n_outs = n_outs
self.seqs_taps = seqs_taps
self.outs_taps = outs_taps
self.destroy_map = {} self.destroy_map = {}
if self.inplace:
for i in xrange(self.n_outs):
# claiming that output "-i" is destroying inputs is the way to
# declare that no real output is aliased to any inputs. We just
# trash the inputs by using them as workspace.
self.destroy_map.update( {-i:[i]})
def __eq__(self,other): def __eq__(self,other):
rval = type(self) == type(other) rval = type(self) == type(other)
if rval: if rval:
rval = (self.grad_fn is other.grad_fn) and \ rval = (self.inputs == other.inputs) and \
(self.n_ins == other.n_ins) and \ (self.outputs == other.outputs) and \
(self.n_seqs == other.n_seqs) and \
(self.n_outs == other.n_outs) and \ (self.n_outs == other.n_outs) and \
(self.inplace == other.inplace) and \ (self.truncate_gradient == other.truncate_gradient) and\
(self.taps == other.taps) (self.seqs_taps == other.seqs_taps) and \
(self.outs_taps == other.outs_taps)
return rval return rval
def __hash__(self): def __hash__(self):
taps_hash = 0
for k,v in self.taps.iteritems():
taps_hash ^= k
for vi in v :
taps_hash ^= vi
return hash(type(self)) ^ \ return hash(type(self)) ^ \
hash(self.grad_fn) ^ \ hash(self.n_seqs) ^ \
hash(self.n_ins) ^ \
hash(self.n_outs) ^ \ hash(self.n_outs) ^ \
hash(self.inplace) ^ taps_hash hash(self.truncate_gradient) ^\
hash_list(self.inputs) ^ \
hash_list(self.outputs) ^ \
hash_dict(self.seqs_taps) ^ \
hash_dict(self.outs_taps)
def make_node(self, *args): def make_node(self, *args):
# input of the gradient op : # input of the gradient op :
# | g_outs | y | ins | outs | other_args | # | g_outs | y | seqs | outs | non_seqs |
# | n_outs | n_outs | n_ins | n_outs | unknown | # | n_outs | n_outs | n_seqs | n_outs | unknown |
# return # return
# | grad of ins | grad of outs | grad of other_args| # | grad of seqs | grad of outs | grad of non_seqs |
# | n_ins | n_outs | unknown | # | n_seqs | n_outs | unknown |
return theano.Apply(self, list(args), return theano.Apply(self, list(args),
[i.type() for i in args[self.n_outs+self.n_outs:] ]) [i.type() for i in args[1+2*self.n_outs:] ])
def perform(self, node, args, storage): def perform(self, node, args, storage):
# get scan inputs # get scan inputs
inputs = args[self.n_outs+self.n_outs:] n_steps = args[0]
ins = inputs[:self.n_ins] inputs = args[2*self.n_outs+1:]
initSt = inputs[self.n_ins:self.n_ins+self.n_outs] seqs = inputs[:self.n_seqs]
otherArgs = inputs[self.n_outs+self.n_ins:] seeds = inputs[self.n_seqs:self.n_seqs+self.n_outs]
non_seqs = inputs[self.n_outs+self.n_seqs:]
# generate space for gradient # generate space for gradient
# not do if inplace !? g_seqs = [numpy.zeros_like(k) for k in seqs]
g_ins = [numpy.zeros_like(k) for k in ins] g_seeds = [numpy.zeros_like(k) for k in seeds]
g_initSt = [numpy.zeros_like(k) for k in initSt] g_non_seqs = [numpy.zeros_like(k) for k in non_seqs]
g_otherArgs = [numpy.zeros_like(k) for k in otherArgs]
# get gradient from above # get gradient from above
g_outs = args[:self.n_outs] g_outs = args[:self.n_outs]
# we modify g_outs inplace ..
if not self.inplace:
g_outs = [gout.copy() for gout in g_outs]
# get the output of the scan operation # get the output of the scan operation
outs = args[self.n_outs:2*self.n_outs] outs = args[self.n_outs:2*self.n_outs]
# check for Nones (non - differentiable )
#for i,g_o in enumerate(g_outs):
# if numpy.all(g_o == 0.):
# g_outs[i] = numpy.zeros_like(outs[i])
# go back through time to 0 (use a time window !?) # go back through time to 0 or n_steps - truncate_gradient
for i in xrange(len(ins[0])-1,-1,-1): lower_limit = n_steps - self.truncate_gradient
if lower_limit > n_steps-1:
the_range = xrange(n_steps-1,-1,-1)
elif lower_limit < -1:
the_range = xrange(n_steps-1,-1,-1)
else:
the_range = xrange(n_steps-1, lower_limit,-1)
seqs_mins = {}
for j in xrange(self.n_seqs):
if self.seqs_taps.has_key(j):
seqs_mins.update({j: min(self.seqs_taps[j])})
outs_mins = {}
seed_size = {}
for j in xrange(self.n_outs):
if self.outs_taps.has_key(j):
outs_mins.update({j: min(self.outs_taps[j])})
seed_size.update({j: g_seeds[j]..shape[0]})
for i in the_range:
# time slice of inputs # time slice of inputs
_ins = [arg[i] for arg in ins] _ins = []
for j in xrange(self.n_seqs)
if self.seqs_taps.has_key(j):
ls_taps = self.seqs_taps[j]
min_tap = seqs_mins[j]
for tap_value in ls_taps:
k = i - min_tap + tap_value
_ins += [ins[j][k]]
# time slice of outputs + taps # time slice of outputs + taps
_outs = [] _outs = []
for j in xrange(self.n_outs): for j in xrange(self.n_outs):
ls_taps = [1] if self.outs_taps.has_key(j):
if self.taps.has_key(j): ls_taps = self.outs_taps[j]
ls_taps += self.taps[j] min_tap = outs_mins[j]
maxVal = max(ls_taps) seed_sz = seed_size[j]
for tap_value in ls_taps: for tap_value in ls_taps:
if i - tap_value < 0: if i + tap_value < 0:
_outs += [initSt[j][maxVal-tap_value+i]] k = i + seed_sz + tap_value
if k < 0 :
#past value not provided .. issue a warning and use 0
_outs += [numpy.zeros(seeds[j][0].shape)]
warning('Past value %d for output $d not given' \
%(j,tap_value))
else: else:
_outs += [outs[j][i- tap_value]] _outs += [seeds[j][[k]]
else:
_outs += [outs[j][i + tap_value]]
g_out = [arg[i] for arg in g_outs] g_out = [arg[i] for arg in g_outs]
grad_args = g_out + _ins + _outs + otherArgs grad_args = g_out + _ins + _outs + non_seqs
grads=self.grad_fn(*grad_args) grads=self.grad_fn(*grad_args)
# get gradient for inputs # get gradient for inputs
for j in xrange(self.n_ins): pos = 0
g_ins[j][i] = grads[j] for j in xrange(self.n_seqs):
if self.seqs_taps.has_key(j):
ls_taps = self.seqs_taps[j]
min_tap = seqs_mins[j]
for tap_value in ls_taps :
k = i - min_tap + tap_value
g_ins[j][k] += grads[pos]
pos += 1
# get gradient for outputs # get gradient for outputs
pos = self.n_ins
for j in xrange(self.n_outs): for j in xrange(self.n_outs):
ls_taps = [1] if self.outs_taps.has_key(j):
if self.taps.has_key(j): ls_taps = self.outs_taps[j]
ls_taps += self.taps[j] min_tap = outs_mins[j]
maxVal = max(ls_taps) seed_sz = seed_size[j]
for tap_value in ls_taps: for tap_value in ls_taps:
if i - tap_value < 0: if i+tap_value < 0 :
g_initSt[j][maxVal-tap_value+i] += grads[pos] k = i + seed_sz + tap_value
pos +=1 if k > 0 :
else: g_seeds[j][k] += grads[pos]
g_outs[j][i-tap_value]+= grads[pos]
pos += 1 pos += 1
for j in xrange(len(g_otherArgs)): for j in xrange(len(g_non_seqs)):
g_otherArgs[j] += grads[j+pos] g_non_seqs[j] += grads[j+pos]
# return the gradient
for i in xrange(len(g_ins)):
storage[i][0] = g_ins[i]
for i in xrange(len(g_initSt)):
storage[i+self.n_ins][0] = g_initSt[i]
for i in xrange(len(g_otherArgs)):
storage[i+self.n_ins+self.n_outs][0] = g_otherArgs[i]
# return the gradient
@gof.local_optimizer([None]) for i,v in enumerate(g_ins + g_seeds+ g_non_seqs):
def grad_scan_make_inplace(node): storage[i][0] = v
op = node.op
if isinstance(op, ScanGrad) and (not op.inplace):
return ScanGrad(op.grad_fn, op.n_ins, op.n_outs, op.taps,
inplace=True).make_node(*node.inputs).outputs
return False
optdb.register('grad_scan_make_inplace', opt.in2out(grad_scan_make_inplace,\
ignore_newtrees=True), 75, 'fast_run', 'inplace')
theano/sandbox/test_scan.py
浏览文件 @ e789f49c
...@@ -7,8 +7,6 @@ import random ...@@ -7,8 +7,6 @@ import random
import numpy.random import numpy.random
from theano.tests import unittest_tools as utt from theano.tests import unittest_tools as utt
def verify_grad(op, pt, n_tests=2, rng=None, eps = None, tol = None, def verify_grad(op, pt, n_tests=2, rng=None, eps = None, tol = None,
mode = None, cast_to_output_type = False): mode = None, cast_to_output_type = False):
pt = [numpy.array(p) for p in pt] pt = [numpy.array(p) for p in pt]
...@@ -75,455 +73,21 @@ def verify_grad(op, pt, n_tests=2, rng=None, eps = None, tol = None, ...@@ -75,455 +73,21 @@ def verify_grad(op, pt, n_tests=2, rng=None, eps = None, tol = None,
class T_Scan(unittest.TestCase):
def setUp(self):
utt.seed_rng()
x_1 = theano.tensor.dscalar('x_1')
self.my_f = theano.function([x_1],[x_1]) #dummy function
# Naming convention :
# u_1,u_2,.. -> inputs, arrays to iterate over
# x_1,x_2,.. -> outputs at t-1 that are required in the recurrent
# computation
# iu_1,iu_2,.. -> inplace inputs, inputs that are being replaced by
# outputs during computation
# du_1,du_2,.. -> dummy inputs used to do inplace computation, they
# are not passed to my_f
# ix_1,ix_2,.. -> inplace outputs at t-1
# x_1_next,.. -> outputs at t
# ix_1_next,.. -> inplace outputs at time t
# w_1,w_2,.. -> weights, paramters over which scan does not iterate
# my_f -> compiled function that will be applied recurrently
# my_op -> operator class
# final_f -> compiled function that applies the Scan operation
# out_1,.. -> outputs of the Scan operation
###################################################################
def test_numberOfIterableInputs(self):
def t1():
my_op = Scan.compiled(self.my_f,-1,1)
def t2():
my_op = Scan.compiled(self.my_f,0,1)
self.failUnlessRaises(ValueError,t1)
self.failUnlessRaises(ValueError,t2)
###################################################################
def test_numberOfOutputs(self):
def t1():
my_op = Scan.compiled(self.my_f,1,-1)
def t2():
my_op = Scan.compiled(self.my_f,1,0)
self.failUnlessRaises(ValueError,t1)
self.failUnlessRaises(ValueError,t2)
#####################################################################
def test_numberOfInplaceOutputs(self):
def t1():
my_op =Scan.compiled(self.my_f,1,1,n_inplace = -1)
def t2():
my_op =Scan.compiled(self.my_f,1,1,n_inplace = 2)
def t3():
my_op =Scan.compiled(self.my_f,2,1,n_inplace=2)
def t4():
my_op =Scan.compiled(self.my_f,1,2,n_inplace=2)
def t5():
my_op =Scan.compiled(self.my_f,1,1,n_inplace=1,n_inplace_ignore=2)
self.failUnlessRaises(ValueError,t1)
self.failUnlessRaises(ValueError,t2)
self.failUnlessRaises(ValueError,t3)
self.failUnlessRaises(ValueError,t4)
self.failUnlessRaises(ValueError,t5)
#####################################################################
def test_taps(self):
def t1():
my_op = Scan.compiled(self.my_f,1,1, taps={2:[3]})
def t2():
my_op = Scan.compiled(self.my_f,1,2, taps={0:[0]})
def t3():
my_op = Scan.compiled(self.my_f,1,2, taps={0:[1]})
self.failUnlessRaises(ValueError,t1)
self.failUnlessRaises(ValueError,t2)
self.failUnlessRaises(ValueError,t3)
#####################################################################
def test_makeNode(self):
def t1():
######### Test inputs of different lengths
# define the function that is applied recurrently
u_1 = theano.tensor.dscalar('u_1')
u_2 = theano.tensor.dscalar('u_2')
x_1 = theano.tensor.dscalar('x_1')
x_1_next = u_1+u_2*x_1
my_f = theano.function([u_1,u_2,x_1],[x_1_next])
# define the function that applies the scan operation
my_op = Scan.compiled(my_f,2,1)
u_1 = theano.tensor.dvector('u_1')
u_2 = theano.tensor.dvector('u_2')
x_1 = theano.tensor.dvector('x_1')
x_1_next = my_op(u_1,u_2,x_1)
final_f = theano.function([u_1,u_2,x_1],[x_1_next])
# test the function final_f
u_1 = numpy.random.rand(3)
u_2 = numpy.random.rand(2)
x_1 = [numpy.random.rand()]
out = final_f(u_1,u_2,x_1)
def t2():
######### Test function does not return correct number of outputs
# define the function that is applied recurrently
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
x_1_next = u_1 * x_1
my_f = theano.function([u_1,x_1],[x_1_next])
# define the function that applies the scan operation
my_op = Scan.compiled(my_f,1,2)
u_1 = theano.tensor.dvector('u_1')
x_1 = theano.tensor.dvector('x_1')
x_2 = theano.tensor.dvector('x_2')
x_1_next,x_2_next = my_op(u_1,x_1,x_2)
final_f = theano.function([u_1,x_1,x_2],[x_1_next,x_2_next])
#generate data
u_1 = numpy.random.rand(3)
x_1 = [numpy.random.rand()]
x_2 = [numpy.random.rand()]
out_1,out_2 = final_f(u_1,x_1,x_2)
self.failUnlessRaises(ValueError,t1)
self.failUnlessRaises(TypeError,t2)
#####################################################################
def test_generator(self):
# compile my_f
u_1 = theano.tensor.dscalar('u_1') # dummy input,
# required if no inplace is used!
x_1 = theano.tensor.dscalar('x_1')
w_1 = theano.tensor.dscalar('w_1')
x_1_next = x_1*w_1
my_f = theano.function([u_1,x_1,w_1],[x_1_next])
# create operation
my_op = Scan.compiled(my_f,1,1)
u_1 = theano.tensor.dvector('u_1') # dummy input, there is no
#inplace, so output will not be put in place of this u_1!
x_1 = theano.tensor.dvector('x_1')
w_1 = theano.tensor.dscalar('w_1')
x_1_next = my_op(u_1,x_1,w_1)
final_f = theano.function([u_1,x_1,w_1],[x_1_next])
#generate data
x_1 = numpy.ndarray(3) # dummy input, just tells for how many time
# steps to run recursively
out_1 = final_f(x_1,[2],2)
self.failUnless(numpy.all(out_1 == numpy.asarray([4,8,16])))
#####################################################################
def test_generator_inplace_no_ignore(self):
# compile my_f
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
w_1 = theano.tensor.dscalar('w_1')
x_1_next = x_1*w_1
my_f = theano.function([u_1,x_1,w_1],[x_1_next])
# create operation
my_op = Scan.compiled(my_f,1,1,n_inplace=1)
iu_1 = theano.tensor.dvector('iu_1')
ix_1 = theano.tensor.dvector('ix_1')
w_1 = theano.tensor.dscalar('w_1')
ix_1_next= my_op(iu_1,ix_1,w_1)
final_f = theano.function([theano.In(iu_1, mutable=True),ix_1,w_1],
[ix_1_next], mode='FAST_RUN')
#generate data
iu_1 = numpy.ndarray(3)
out_1 = final_f(iu_1,[2],2)
# not concretely implemented yet ..
self.failUnless(numpy.all(out_1 == numpy.asarray([4,8,16])))
self.failUnless(numpy.all(out_1 == iu_1))
#####################################################################
def test_generator_inplace_no_ignore_2states(self):
# compile my_f
u_1 = theano.tensor.dscalar('u_1')
u_2 = theano.tensor.dscalar('u_2')
x_1 = theano.tensor.dscalar('x_1')
x_2 = theano.tensor.dscalar('x_2')
w_1 = theano.tensor.dscalar('w_1')
x_1_next = x_1*w_1
x_2_next = x_2*w_1
my_f = theano.function([u_1,u_2,x_1,x_2,w_1],[x_1_next,x_2_next])
# create operation
my_op = Scan.compiled(my_f,2,2,n_inplace=2)
iu_1 = theano.tensor.dvector('iu_1')
iu_2 = theano.tensor.dvector('iu_2')
ix_1 = theano.tensor.dvector('ix_1')
ix_2 = theano.tensor.dvector('ix_2')
w_1 = theano.tensor.dscalar('w_1')
ix_1_next,ix_2_next= my_op(iu_1,iu_2,ix_1,ix_2,w_1)
final_f = theano.function([theano.In(iu_1, mutable=True),
theano.In(iu_2, mutable=True),ix_1,ix_2,
w_1],[ix_1_next,ix_2_next], mode='FAST_RUN')
#generate data # Naming convention :
iu_1 = numpy.ndarray(3) # u_1,u_2,.. -> sequences
iu_2 = numpy.ndarray(3) # s_1,s_2,.. -> initial states
out_1,out_2 = final_f(iu_1,iu_2,[2],[1],2) # w_1,w_2,.. -> non-sequences
# not concretely implemented yet .. ###################################
self.failUnless(numpy.all(out_1 == numpy.asarray([4,8,16])))
self.failUnless(numpy.all(out_1 == iu_1))
self.failUnless(numpy.all(out_2 == numpy.asarray([2,4,8])))
self.failUnless(numpy.all(out_2 == iu_2))
####################################################################### class T_Scan(unittest.TestCase):
def test_generator_inplace(self): def setUp(self):
#compile my_f utt.seed_rng()
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
x_2 = theano.tensor.dscalar('x_2')
x_1_next = u_1 + x_1
x_2_next = x_1 * x_2
my_f = theano.function([u_1,x_1,x_2],[x_1_next,x_2_next])
# create operation
my_op = Scan.compiled(my_f,2,2,n_inplace=2,n_inplace_ignore=1)
du_1 = theano.tensor.dvector('du_1')
iu_1 = theano.tensor.dvector('iu_1')
ix_1 = theano.tensor.dvector('ix_1')
ix_2 = theano.tensor.dvector('ix_2')
ix_1_next,ix_2_next = my_op(du_1,iu_1,ix_1,ix_2)
final_f=theano.function([theano.In(du_1, mutable = True),
theano.In(iu_1, mutable = True),
ix_1,ix_2],[ix_1_next,ix_2_next],mode='FAST_RUN')
# generate data
du_1 = numpy.asarray([0.,0.,0.])
iu_1 = numpy.asarray([1.,1.,1.])
ix_1 = [1]
ix_2 = [1]
out_1,out_2 = final_f(du_1,iu_1,ix_1,ix_2)
self.failUnless(numpy.all(out_1 == numpy.asarray([2,3,4])))
self.failUnless(numpy.all(out_2 == numpy.asarray([1,2,6])))
self.failUnless(numpy.all(out_1 == du_1))
self.failUnless(numpy.all(out_2 == iu_1))
#####################################################################
def tets_iterateOnlyOverX(self):
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
x_1_next = u_1*x_1
my_f = theano.function([u_1,x_1],[x_1_next])
my_op = Scan.compiled(my_f,1,1)
u_1 = theano.tensor.dvector('u_1')
x_1 = theano.tensor.dvector('x_1')
x_1_next = my_op(u_1,x_1)
final_f = theano.function([x_1,u_1],[x_1_next])
u_1 = numpy.asarray([2,2,2])
out_1 = final_f(inp,2)
self.failUnless(numpy.all(out_1==numpy.asarray([4,8,16])))
#####################################################################
def test_iterateOverSeveralInputs(self):
u_1 = theano.tensor.dscalar('u_1') # input 1
u_2 = theano.tensor.dscalar('u_2') # input 2
x_1 = theano.tensor.dscalar('x_1') # output
x_1_next = (u_1+u_2)*x_1
my_f = theano.function([u_1,u_2,x_1],[x_1_next])
my_op = Scan.compiled(my_f,2,1)
u_1 = theano.tensor.dvector('u_1')
u_2 = theano.tensor.dvector('u_2')
x_1 = theano.tensor.dvector('x_1')
x_1_next = my_op(u_1,u_2,x_1)
final_f = theano.function([u_1,u_2,x_1],[x_1_next])
u_1 = numpy.asarray([1,1,1])
u_2 = numpy.asarray([1,1,1])
x_1 = [2]
out_1 = final_f(u_1,u_2,x_1)
self.failUnless(numpy.all(out_1==numpy.asarray([4,8,16])))
#####################################################################
def test_iterateOverSeveralInputsSeveralInplace(self):
iu_1 = theano.tensor.dscalar('iu_1')
u_1 = theano.tensor.dscalar('u_1')
u_2 = theano.tensor.dscalar('u_2')
u_3 = theano.tensor.dscalar('u_3')
u_4 = theano.tensor.dscalar('u_4')
ix_1 = theano.tensor.dscalar('ix_1')
ix_2 = theano.tensor.dscalar('ix_2')
x_1 = theano.tensor.dscalar('x_1')
w_1 = theano.tensor.dscalar('w_1')
ix_1_next = u_3 + u_4
ix_2_next = ix_1 + ix_2
x_1_next = x_1 + u_3 + u_4 + ix_1 + ix_2
my_f = theano.function([iu_1,u_1,u_2,u_3,u_4,ix_1,ix_2,x_1,w_1],\
[ix_1_next,ix_2_next, x_1_next])
my_op = Scan.compiled(my_f,6,3, n_inplace=2,\
n_inplace_ignore=1)
du_1 = theano.tensor.dvector('du_1')
iu_1 = theano.tensor.dvector('iu_1')
u_1 = theano.tensor.dvector('u_1')
u_2 = theano.tensor.dvector('u_2')
u_3 = theano.tensor.dvector('u_3')
u_4 = theano.tensor.dvector('u_4')
x_1 = theano.tensor.dvector('x_1')
ix_1 = theano.tensor.dvector('ix_1')
ix_2 = theano.tensor.dvector('ix_2')
w_1 = theano.tensor.dscalar('w_1')
[ix_1_next,ix_2_next,x_1_next]= \
my_op(du_1,iu_1,u_1,u_2,u_3,u_4,x_1,ix_1,ix_2,w_1)
final_f=theano.function([theano.In(du_1, mutable = True),
theano.In(iu_1, mutable = True),
u_1,u_2,u_3,u_4,ix_1,ix_2,x_1,w_1],
[ix_1_next,ix_2_next,
x_1_next],mode='FAST_RUN')
#generate data
du_1 = numpy.asarray([0.,0.,0.])
iu_1 = numpy.asarray([0.,1.,2.])
u_1 = numpy.asarray([1.,2.,3.])
u_2 = numpy.asarray([1.,1.,1.])
u_3 = numpy.asarray([2.,2.,2.])
u_4 = numpy.asarray([3.,2.,1.])
x_1 = [1.]
ix_1 = [1.]
ix_2 = [1.]
w_1 = 2.
out_1,out_2,out_3 = final_f(du_1,iu_1,u_1,u_2,u_3,u_4,\
ix_1,ix_2,x_1,w_1)
self.failUnless(numpy.all(out_3 == numpy.asarray([8.,19.,33.])))
self.failUnless(numpy.all(out_1 == numpy.asarray([5.,4.,3.])))
self.failUnless(numpy.all(out_2 == numpy.asarray([2.,7.,11.])))
self.failUnless(numpy.all(out_1 == du_1))
self.failUnless(numpy.all(out_2 == iu_1))
#####################################################################
def test_computeInPlaceArguments(self):
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
w_1 = theano.tensor.dscalar('w_1')
x_1_next = u_1*w_1+x_1
my_f = theano.function([u_1,x_1,theano.In(w_1,update=w_1*2)],
[x_1_next])
my_op = Scan.compiled(my_f,1,1)
u_1 = theano.tensor.dvector('u_1')
x_1 = theano.tensor.dvector('x_1')
w_1 = theano.tensor.dscalar('w_1')
x_1_next = my_op(u_1,x_1,w_1)
final_f = theano.function([u_1,x_1,w_1], [x_1_next])
u_1 = [1.,1.,1.]
x_1 = [1.]
w_1 = 1.
out_1 = final_f(u_1,x_1,w_1)
self.failUnless(numpy.all(out_1 == numpy.asarray([2,4,8])))
#####################################################################
def test_timeTaps(self):
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
x_1_t2 = theano.tensor.dscalar('x_1_t2')
x_1_t4 = theano.tensor.dscalar('x_1_t4')
x_1_next = u_1+x_1+x_1_t2+x_1_t4
my_f = theano.function([u_1,x_1,x_1_t2,x_1_t4],[x_1_next])
my_op = Scan.compiled(my_f,1,1,taps={0:[2,4]})
u_1 = theano.tensor.dvector('u_1')
x_1 = theano.tensor.dvector('x_1')
x_1_next = my_op(u_1,x_1)
final_f = theano.function([u_1,x_1],[x_1_next])
u_1 = [1.,1.,1.,1.,1.]
x_1 = [1.,2.,3.,4.]
out_1 = final_f(u_1,x_1)
self.failUnless(numpy.all(out_1==numpy.asarray([9.,16.,29.,50.,89.])))
#####################################################################
def test_constructFunction(self):
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
x_1_next = u_1 + x_1
my_op = Scan.symbolic(([u_1,x_1],x_1_next),1,1)
u_1 = theano.tensor.dvector('u_1')
x_1 = theano.tensor.dvector('x_1')
x_1_next = my_op(u_1,x_1)
final_f = theano.function([u_1,x_1],[x_1_next])
u_1 = [1.,1.,1.]
x_1 = [1.]
out_1 = final_f(u_1,x_1)
self.failUnless(numpy.all(out_1==numpy.asarray([2.,3.,4.])))
######################################################################
def test_gradOneInputOneOutput(self):
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
x_1_next = u_1*x_1
my_op = Scan.symbolic( ([u_1,x_1],x_1_next), 1,1)
u_1 = [1.,2.,3.]
x_1 = [1.]
verify_grad( my_op , [u_1,x_1] )
#######################################################################
def test_gradManyInputsManyOutputs(self):
u_1 = theano.tensor.dscalar('u_1')
u_2 = theano.tensor.dscalar('u_2')
x_1 = theano.tensor.dscalar('x_1')
x_2 = theano.tensor.dscalar('x_2')
x_1_next = x_1*u_1+x_2
x_2_next = x_2*u_2+x_1
my_op = Scan.symbolic( ([u_1,u_2,x_1,x_2],
[x_1_next,x_2_next]),
2,2)
u_1 = [1.,.2,3.]
u_2 = [1.5,1.25,.35]
x_1 = [.5]
x_2 = [.65]
verify_grad(my_op, [u_1,u_2,x_1,x_2])
######################################################################
def test_gradTimeTaps(self):
u_1 = theano.tensor.dscalar('u_1')
x_1 = theano.tensor.dscalar('x_1')
x_1_t_2 = theano.tensor.dscalar('x_1_t_2')
x_1_next = x_1_t_2*x_1*u_1
my_op = Scan.symbolic( ([u_1,x_1,x_1_t_2],
[x_1_next]),
1,1,taps={0:[2]})
u_1 = [1.,2.,3.,4.]
x_1 = [2.,3.]
verify_grad(my_op, [u_1,x_1])
#######################################################################
def test_gradManyInputsManyOutputsTimeTaps(self):
u_1 = theano.tensor.dscalar('u_1')
u_2 = theano.tensor.dscalar('u_2')
x_1 = theano.tensor.dscalar('x_1')
x_1_2 = theano.tensor.dscalar('x_1_2')
x_2 = theano.tensor.dscalar('x_2')
x_2_2 = theano.tensor.dscalar('x_2_2')
x_1_n = x_1*x_2_2 + u_1*x_1_2
x_2_n = x_2*x_1_2 + u_2*x_2_2
my_op = Scan.symbolic(([u_1,u_2,x_1,x_1_2,
x_2,x_2_2],[x_1_n,
x_2_n]),2,2,taps=
{0:[2],1:[2]})
u_1 = [1.,2.,3.,4.]
u_2 = [3.,2.,4.,1.]
x_1 = [0.1,0.2]
x_2 = [1.5,3.5]
verify_grad(my_op, [u_1,u_2,x_1,x_2]) def test_one(self):
pass
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论