changes into the tutorials

doc/tutorial/adding.txt

@@ -8,8 +8,8 @@ Baby steps - Adding two numbers together
 Adding two scalars
 ==================
 
-So, to get us started and get a feel of what we're working with, let's
-make a simple function: add two numbers together. Here is how you do
+So, to get us started with Theano and get a feel of what we're working with, 
+let's make a simple function: add two numbers together. Here is how you do
 it:
 
 >>> x = T.dscalar('x')
@@ -26,7 +26,7 @@ array(28.4)
 
 
 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  representing the quantities that you want
 to add. Note that from now on, we will use the term :term:`Variable`
 to mean "symbol" (in other words, ``x``, ``y``, ``z`` are all Variable
 objects). The output of the function ``f`` is a ``numpy.ndarray``
@@ -36,7 +36,6 @@ If you are following along and typing into an interpreter, you may have
 noticed that there was a slight delay in executing the ``function``
 instruction. Behind the scenes, ``f`` was being compiled into C code.
 
-    .. TODO: help
 
 -------------------------------------------
 
@@ -64,8 +63,7 @@ TensorType(float64, scalar)
 >>> x.type == T.dscalar
 True
 
-You can learn more about the structures in Theano in
-the :ref:`advtutorial` and in :ref:`graphstructures`.
+You can learn more about the structures in Theano in :ref:`graphstructures`.
 
 By calling ``T.dscalar`` with a string argument, you create a
 :term:`Variable` representing a floating-point scalar quantity with the

doc/tutorial/examples.txt

@@ -137,6 +137,9 @@ with respect to the second. In this way, Theano can be used for
 `automatic differentiation`_.
 
 .. note::
+   
+   The second argument of ``T.grad`` can be a list, case in which it 
+   will 
 
    The variable of ``T.grad`` has the same dimensions as the
    second argument. This is exactly like the first derivative if the

doc/tutorial/index.txt

@@ -10,7 +10,7 @@ Let's start an interactive session and import Theano.
 >>> from theano import *
 
 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).
 
 >>> import theano.tensor as T

doc/tutorial/numpy.txt

@@ -8,10 +8,9 @@ NumPy refresher
 
 Here are some quick guides to NumPy:
   * `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]
 
 
@@ -20,8 +19,10 @@ Matrix conventions for machine learning
 
 
 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.
-So to make a NN out of it, multiply by a weight matrix of size (5, #hid).
+Every row is an example. Therefore, inputs[10,5] is a matrix of 10 examples 
+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:
 
@@ -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,
 so each thing that is contiguous is a row.  That is, there are 3 rows
 and 2 columns.
+
+Broadcasting
+============
+
+Numpy does :term:`broadcasting` of numpy 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>`__ .