theano -> Theano

doc/advanced_tutorial/graphstructures.txt

@@ -68,12 +68,12 @@ This is what you would normally type:
 .. code-block:: python
 
     from theano.tensor import *
-            
+
     # create 3 Variables with owner = None
     x = matrix('x')
     y = matrix('y')
     z = matrix('z')
-    
+
     # create 2 Variables (one for 'e', one intermediate for y*z)
     # create 2 Apply instances (one for '+', one for '*')
     e = x + y * z
@@ -86,7 +86,7 @@ This is what you would type to build the graph explicitly:
 .. code-block:: python
 
     from theano.tensor import *
-    
+
     # Instantiate a type that represents a matrix of doubles
     float64_matrix = TensorType(dtype = 'float64',              # double
                                 broadcastable = (False, False)) # matrix
@@ -129,7 +129,7 @@ Note how the call to ``Apply`` modifies the ``owner`` and ``index``
 fields of the :ref:`Variables <variable>` passed as outputs to point to
 itself and the rank they occupy in the output list. This whole
 machinery builds a DAG (Directed Acyclic Graph) representing the
-computation, a graph that theano can compile and optimize.
+computation, a graph that Theano can compile and optimize.
 
 
 Automatic wrapping
@@ -189,8 +189,8 @@ inputs. Therefore, an Apply node may be obtained from an Op
 and a list of inputs by calling ``Op.make_node(*inputs)``.
 
 Comparing with the Python language, an :ref:`apply` node is
-theano's version of a function call whereas an :ref:`op` is
-theano's version of a function definition.
+Theano's version of a function call whereas an :ref:`op` is
+Theano's version of a function definition.
 
 An Apply instance has three important fields:
 

doc/advanced_tutorial/inplace.txt

@@ -94,7 +94,7 @@ operation on ``x``.
 
 .. note::
 
-   Inplace operations in theano still work in a functional setting:
+   Inplace operations in Theano still work in a functional setting:
    they need to return the modified input. Symbolically, Theano
    requires one Variable standing for the input *before* being modified
    and *another* Variable representing the input *after* being

doc/advanced_tutorial/type.txt

@@ -160,7 +160,7 @@ the Type is to instantiate a plain Type and set the needed fields:
 
 .. code-block:: python
 
-   from theano import gof
+   from Theano import gof
 
    double = gof.Type()
    double.filter = filter
@@ -216,7 +216,7 @@ There are several ways to make sure that equality testing works properly:
  #. Hide the Double class and only advertise a single instance of it.
 
 Here we will prefer the final option, because it's the simplest.
-Often Ops in the theano code define the ``__eq__`` function though.
+Often Ops in the Theano code define the ``__eq__`` function though.
 
 
 Untangling some concepts

doc/examples/module/mechanism2.py

@@ -9,7 +9,7 @@ class AccumulatorInstance(ModuleInstance):
 
 class Accumulator(Module):
 
-    # This line tells theano to instantiate an AccumulatorInstance
+    # This line tells Theano to instantiate an AccumulatorInstance
     # when make() is called.
     InstanceType = AccumulatorInstance
 

doc/glossary.txt

@@ -93,8 +93,8 @@ Glossary of terminology
     type
         See :ref:`tensortypes`
 
-    Variable 
-        A :ref:`variable` is the main data structure you work with when
+    Variable
+        A :ref:`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