Merge pull request #1060 from delallea/minor

doc/cifarSC2011/theano.txt

@@ -208,7 +208,7 @@ Exercise 2
 
 
     # Construct Theano expression graph
-    p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probabily of having a one
+    p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probability of having a one
     prediction = p_1 > 0.5 # The prediction that is done: 0 or 1
     xent = -y*T.log(p_1) - (1-y)*T.log(1-p_1) # Cross-entropy
     cost = xent.mean() + 0.01*(w**2).sum() # The cost to optimize

doc/hpcs2011_tutorial/logreg_example.py

@@ -20,7 +20,7 @@ y.tag.test_value = D[1]
 
 
 # Construct Theano expression graph
-p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probabily of having a one
+p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probability of having a one
 prediction = p_1 > 0.5 # The prediction that is done: 0 or 1
 xent = -y*T.log(p_1) - (1-y)*T.log(1-p_1) # Cross-entropy
 cost = xent.mean() + 0.01*(w**2).sum() # The cost to optimize

doc/tutorial/extending_theano.txt

@@ -9,7 +9,7 @@ Theano Graphs
 =============
 
 - Theano works with symbolic graphs.
-- Those graphs are bi-partite graphs (graph with 2 types of nodes).
+- Those graphs are bi-partite graphs (graphs with 2 types of nodes).
 - The two types of nodes are ``Apply`` and ``Variable`` nodes.
 - Each ``Apply`` node has a link to the op that it executes.
 
@@ -359,7 +359,7 @@ file containing a specific test of interest and run the file. In this example, t
        t.setUp()
        t.test_double_rop()
 
-We recommand that when we execute a file, we run all tests in that
+We recommend that when we execute a file, we run all tests in that
 file. This can be done by adding this at the end of your test files:
 
 .. code-block:: python

doc/tutorial/modes.txt

@@ -67,7 +67,7 @@ Consider the logistic regression:
     #print w.get_value(), b.get_value()
 
     # Construct Theano expression graph
-    p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probabily of having a one
+    p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probability of having a one
     prediction = p_1 > 0.5 # The prediction that is done: 0 or 1
     xent = -y*T.log(p_1) - (1-y)*T.log(1-p_1) # Cross-entropy
     cost = xent.mean() + 0.01*(w**2).sum() # The cost to optimize
@@ -110,7 +110,7 @@ as it will be useful later on.
 
 .. Note::
 
-   * Apply the Theano flag ``floatX=float32`` through (``theano.config.floatX``) in your code.
+   * Apply the Theano flag ``floatX=float32`` (through ``theano.config.floatX``) in your code.
    * Cast inputs before storing them into a shared variable.
    * Circumvent the automatic cast of *int32* with *float32* to *float64*:
     

doc/tutorial/modes_solution_1.py

@@ -27,7 +27,7 @@ y.tag.test_value = D[1]
 #print w.get_value(), b.get_value()
 
 # Construct Theano expression graph
-p_1 = 1 / (1 + tt.exp(-tt.dot(x, w) - b))  # Probabily of having a one
+p_1 = 1 / (1 + tt.exp(-tt.dot(x, w) - b))  # Probability of having a one
 prediction = p_1 > 0.5  # The prediction that is done: 0 or 1
 xent = -y * tt.log(p_1) - (1 - y) * tt.log(1 - p_1)  # Cross-entropy
 cost = tt.cast(xent.mean(), 'float32') + \

doc/tutorial/printing_drawing.txt

@@ -42,7 +42,7 @@ The following output depicts the pre- and post- compilation graphs.
 
 
     # Construct Theano expression graph
-    p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) # Probabily of having a one
+    p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) # Probability of having a one
     prediction = p_1 > 0.5 # The prediction that is done: 0 or 1
     xent = -y * T.log(p_1) - (1 - y) * T.log(1 - p_1) # Cross-entropy
     cost = xent.mean() + 0.01 * (w ** 2).sum() # The cost to optimize

doc/tutorial/using_gpu.txt

@@ -342,7 +342,7 @@ Consider again the logistic regression:
     #print w.get_value(), b.get_value()
 
     # Construct Theano expression graph
-    p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probabily of having a one
+    p_1 = 1 / (1 + T.exp(-T.dot(x, w)-b)) # Probability of having a one
     prediction = p_1 > 0.5 # The prediction that is done: 0 or 1
     xent = -y*T.log(p_1) - (1-y)*T.log(1-p_1) # Cross-entropy
     cost = xent.mean() + 0.01*(w**2).sum() # The cost to optimize
@@ -400,7 +400,7 @@ What can be done to further increase the speed of the GPU version? Put your idea
    * Use the Theano flag ``device=gpu`` to require use of the GPU device.
    * Use ``device=gpu{0, 1, ...}`` to specify which GPU if you have more than one.
  
-   * Apply the Theano flag ``floatX=float32`` through (``theano.config.floatX``) in your code.
+   * Apply the Theano flag ``floatX=float32`` (through ``theano.config.floatX``) in your code.
    * ``Cast`` inputs before storing them into a ``shared`` variable.
    * Circumvent the automatic cast of *int32* with *float32* to *float64*:
     
@@ -623,5 +623,4 @@ only applicable to computations involving a single output. Hence, to gain
 efficiency over the basic solution that is asked here, the two operations would
 have to be jointly optimized explicitly in the code.)
 
-Modify and execute to support *stride* (i.e. so as not constrain the input to be *C-contiguous*).
-
+Modify and execute to support *stride* (i.e. to avoid constraining the input to be *C-contiguous*).

doc/tutorial/using_gpu_solution_1.py

@@ -38,7 +38,7 @@ y.tag.test_value = D[1]
 #print w.get_value(), b.get_value()
 
 # Construct Theano expression graph
-p_1 = 1 / (1 + tt.exp(-tt.dot(x, w) - b))  # Probabily of having a one
+p_1 = 1 / (1 + tt.exp(-tt.dot(x, w) - b))  # Probability of having a one
 prediction = p_1 > 0.5  # The prediction that is done: 0 or 1
 xent = -y * tt.log(p_1) - (1 - y) * tt.log(1 - p_1)  # Cross-entropy
 cost = tt.cast(xent.mean(), 'float32') + \

theano/sandbox/scan_module/scan.py

@@ -132,7 +132,7 @@ def scan(fn,
         The list of ``non_sequences`` can also contain shared variables
         used in the function, though ``scan`` is able to figure those
         out on its own so they can be skipped. For the clarity of the
-        code we recommand though to provide them to scan. To some extend
+        code we recommend though to provide them to scan. To some extend
         ``scan`` can also figure out other ``non sequences`` (not shared)
         even if not passed to scan (but used by `fn`). A simple example of
         this would be :

theano/scan_module/scan.py

@@ -130,7 +130,7 @@ def scan(fn,
         The list of ``non_sequences`` can also contain shared variables
         used in the function, though ``scan`` is able to figure those
         out on its own so they can be skipped. For the clarity of the
-        code we recommand though to provide them to scan. To some extend
+        code we recommend though to provide them to scan. To some extend
         ``scan`` can also figure out other ``non sequences`` (not shared)
         even if not passed to scan (but used by `fn`). A simple example of
         this would be :

theano/tensor/basic.py

@@ -2685,6 +2685,7 @@ where = switch
 # Bit-wise
 ##########################
 
+
 @_scal_elemwise_with_nfunc('bitwise_and', 2, 1)
 def and_(a, b):
     """bitwise a & b"""
@@ -4334,8 +4335,10 @@ class Subtensor(Op):
         while (inner_ii < %(c_prefix)s_NDIM(%(xview)s))
         {
             assert (outer_ii < %(c_prefix)s_NDIM(%(x)s));
-            %(set_dim)s(%(xview)s, inner_ii, %(c_prefix)s_DIMS(%(x)s)[outer_ii]);
-            %(set_stride)s(%(xview)s, inner_ii, %(c_prefix)s_STRIDES(%(x)s)[outer_ii]);
+            %(set_dim)s(%(xview)s, inner_ii,
+                        %(c_prefix)s_DIMS(%(x)s)[outer_ii]);
+            %(set_stride)s(%(xview)s, inner_ii,
+                           %(c_prefix)s_STRIDES(%(x)s)[outer_ii]);
             inner_ii += 1;
             outer_ii += 1;
         }
@@ -4464,19 +4467,20 @@ def set_subtensor(x, y, inplace=False,
     return inc_subtensor(x, y, inplace, set_instead_of_inc=True,
             tolerate_inplace_aliasing=tolerate_inplace_aliasing)
 
+
 def batched_dot(x, y):
     """
     :param x: A Tensor with sizes e.g.: for  3D (dim1, dim3, dim2)
     :param y: A Tensor with sizes e.g.: for 3D (dim1, dim2, dim4)
-    This function computes the dot product between the two tensors, by iterating
-    over the first dimension using scan.
+    This function computes the dot product between the two tensors, by
+    iterating over the first dimension using scan.
     Returns a tensor of size e.g. if it is 3D: (dim1, dim3, dim4)
     Example:
     >>> first = T.tensor3('first')
     >>> second = T.tensor3('second')
     >>> result = batched_dot(first, second)
     :note:  This is a subset of numpy.einsum, but we do not provide it for now.
-    But numpy einsum is slower then dot or tensordot:
+    But numpy einsum is slower than dot or tensordot:
     http://mail.scipy.org/pipermail/numpy-discussion/2012-October/064259.html
     """
     result, updates = theano.scan(fn=lambda x_mat, y_mat:
@@ -4486,6 +4490,7 @@ def batched_dot(x, y):
             non_sequences=None)
     return result
 
+
 def inc_subtensor(x, y, inplace=False, set_instead_of_inc=False,
         tolerate_inplace_aliasing=False):
     """Return x with the given subtensor incremented by y.
@@ -5725,7 +5730,8 @@ class Reshape(Op):
                 // -- will err if this will downcast. This could happen if the
                 // -- user pass an int64 dtype, but npy_intp endup being int32.
                 new_dims[ii] = ((dtype_%(shp)s*)(
-                        PyArray_BYTES(%(shp)s) + ii * PyArray_STRIDES(%(shp)s)[0]))[0];
+                        PyArray_BYTES(%(shp)s) +
+                        ii * PyArray_STRIDES(%(shp)s)[0]))[0];
             }
             Py_XDECREF(%(z)s);
             %(z)s = (PyArrayObject *) PyArray_Newshape(%(x)s, &newshape,
@@ -5937,8 +5943,8 @@ def tile(x, reps, ndim=None):
         ndim = len(reps)
 
     # backport
-    # ndim = len(reps) if ndim is None else ndim # not sure if len(shp) is going
-    # to work.
+    # ndim = len(reps) if ndim is None else ndim
+    # not sure if len(shp) is going to work.
     if ndim not in tile.op:
         tile.op[ndim] = Tile(ndim)
     return tile.op[ndim](x, reps)