Merge pull request #5433 from notoraptor/windoc

EMAIL.txt

@@ -66,8 +66,7 @@ features:
 
  * tight integration with NumPy: a similar interface to NumPy's.
    numpy.ndarrays are also used internally in Theano-compiled functions.
- * transparent use of a GPU: perform data-intensive computations up to
-   140x faster than on a CPU (support for float32 only).
+ * transparent use of a GPU: perform data-intensive computations much faster than on a CPU.
  * efficient symbolic differentiation: Theano can compute derivatives
    for functions of one or many inputs.
  * speed and stability optimizations: avoid nasty bugs when computing

doc/index.txt

@@ -7,7 +7,7 @@ evaluate mathematical expressions involving multi-dimensional
 arrays efficiently. Theano features:
 
 * **tight integration with NumPy** -- Use `numpy.ndarray` in Theano-compiled functions.
-* **transparent use of a GPU** -- Perform data-intensive calculations up to 140x faster than with CPU.(float32 only)
+* **transparent use of a GPU** -- Perform data-intensive computations much faster than on a CPU.
 * **efficient symbolic differentiation** -- Theano does your derivatives for functions with one or many inputs.
 * **speed and stability optimizations** -- Get the right answer for ``log(1+x)`` even when ``x`` is really tiny.
 * **dynamic C code generation** -- Evaluate expressions faster.

doc/install_centos6.txt

@@ -12,6 +12,7 @@ CentOS 6 Installation Instructions
     page <http://deeplearning.net/software/theano_versions/dev/install_centos6.html>`_.
 
 .. |PlatformCompiler| replace:: ``python-dev``, ``g++`` >= 4.2
+.. |CompilerName| replace:: ``g++``
 
 .. include:: requirements.inc
 

doc/install_generic.inc

@@ -9,6 +9,24 @@ Installation
 Stable Installation
 -------------------
 
+With ``conda``
+^^^^^^^^^^^^^^
+
+If you use conda, you can directly install both theano and pygpu. Libgpuarray
+will be automatically installed as a dependency.
+
+.. code-block:: bash
+
+    conda install theano pygpu
+
+With ``pip``
+^^^^^^^^^^^^
+
+If you use pip, you have to install Theano and libgpuarray separately.
+
+theano
+::::::
+
 Install the latest stable version of Theano with:
 
 .. raw:: html
@@ -27,23 +45,18 @@ Install the latest stable version of Theano with:
 
 If you encountered any trouble, head to the :ref:`troubleshooting` page.
 
-libgpuarray
-^^^^^^^^^^^
-
-It is recommanded that you don't use 0.8.2 for the new back-end. Use
-the dev version of Theano or 0.9rc3.
+The latest stable version of Theano is ``0.9.0`` (tagged with ``rel-0.9.0``).
 
-For the stable version of Theano(0.8.2) you need a specific version of libgpuarray,
-that has been tagged ``v-9998``.
-Download it with:
+libgpuarray
+:::::::::::
 
-.. raw:: html
+For the stable version of Theano you need a specific version of libgpuarray,
+that has been tagged ``v0.6.2``.
+Download it with::
 
-    <div class='highlight'><pre>
-    git clone https://github.com/Theano/libgpuarray.git --tags
-    git checkout origin/v-9998
+    git clone https://github.com/Theano/libgpuarray.git
     cd libgpuarray
-    </pre></div>
+    git checkout tags/v0.6.2 -b v0.6.2
 
 and then follow the `Step-by-step instructions <http://deeplearning.net/software/libgpuarray/installation.html#step-by-step-install>`__.
 

doc/install_macos.txt

@@ -20,6 +20,7 @@ alternative instructions here.
 .. _theano-users: http://groups.google.com/group/theano-users?pli=1
 
 .. |PlatformCompiler| replace:: ``clang`` (the system version)
+.. |CompilerName| replace:: ``Clang``
 
 .. include:: requirements.inc
 

doc/install_ubuntu.txt

@@ -14,6 +14,7 @@ Ubuntu Installation Instructions
 .. _gpu_linux:
 
 .. |PlatformCompiler| replace:: ``python-dev``, ``g++`` >= 4.2
+.. |CompilerName| replace:: ``g++``
 
 .. include:: requirements.inc
 

doc/install_windows.txt

+.. include:: css.inc
+
 .. _install_windows:
 
+
 Windows Installation Instructions
-=================================
+#################################
 
 .. warning::
     If you want to install the bleeding-edge or development version of Theano
     from GitHub, please make sure you are reading `the latest version of this
     page <http://deeplearning.net/software/theano_versions/dev/install_windows.html>`_.
 
-.. warning::
-
-    Theano is mainly developed and tested on Linux Machines.
-
-These instructions show step-by-step how to install Theano and
-required dependencies on a 32- or 64-bit system using freely available
-tools and compilers.
+.. |PlatformCompiler| replace:: ``python-dev``, ``g++`` >= 4.2
+.. |CompilerName| replace:: ``g++``
 
-Installing Dependencies
-~~~~~~~~~~~~~~~~~~~~~~~
+.. List of requirements, optional requirements, and installation of miniconda.
+.. include:: requirements.inc
+    :end-before: .. install_requirements_and_optional_packages
 
-.. note::
-
-    Command lines listed below are assumed to be run in a Windows prompt:
-    To open the prompt on Windows <= 7, click ``Start`` and type the ``cmd`` command to launch a command window.
-    In Windows 8, go to the Start screen and type ``command`` or ``cmd``.
+Install requirements and optional packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+.. code-block:: bash
 
-Theano currently works on Windows, however it requires compilers for
-C/C++ (for Python 2.7 family this has to be Microsoft Visual Studio
-2008 compiler), CUDA (CUDA v5.5 is required as it is the latest
-version supporting Visual Studio 2008), and GCC (for non-CUDA C code
-generated by Theano).
+    conda install numpy scipy mkl-service libpython <m2w64-toolchain> <nose> <nose-parameterized> <sphinx> <pydot-ng>
 
+.. note::
 
+    * Arguments between <...> are optional.
+    * ``m2w64-toolchain`` package provides a fully-compatible version of GCC and is then highly recommended.
 
 .. _gpu_windows:
 
-Visual Studio and CUDA
-######################
-
-Unfortunately Microsoft recently stopped distributing Visual Studio
-Express 2008 (the compilers required for Python 2.7 are provided,
-though), therefore we require a temporary install of Visual Studio Express
-2010 to be able to install CUDA (its installer requires a Visual
-Studio installation to proceed). Afterwards, the Visual Studio 2010
-can be safely removed. If someone knows how to install CUDA 5.5
-without a proper Visual Studio installation, please let us know.
-
-First we need to install Microsoft Visual Studio 2010 Express, which
-is required to install CUDA. You can download it from
-`Visual Studio Express
-<http://www.visualstudio.com/en-us/products/visual-studio-express-vs.aspx>`_.
-Please install the Visual C version. We have downloaded the
-`all-in-one CD <http://go.microsoft.com/?linkid=9709969>`_, extracted
-it using `7zip <http://www.7-zip.org/>`_, and ran the installer at
-VCExpress\\setup.exe.
+Install and configure the GPU drivers (recommended)
+---------------------------------------------------
 
-If you want a 64bit Python installation, Visual Studio 2010 Express
-doesn't provide a 64bit compiler. To get one download and install the
-`Windows Software Development Kit version 7.1
-<http://msdn.microsoft.com/en-us/windowsserver/bb980924.aspx>`_.
-
-Now you have a running (and free even for commercial use) installation
-of MSVS2010 IDE with 32- and 64-bit compilers.
+.. warning::
 
-Once Visual Studio is installed, you can install CUDA. We recommend
-CUDA 5.5, as it supports MSVC 2008. Download the CUDA installer from
-`the CUDA archive
-<https://developer.nvidia.com/cuda-toolkit-55-archive>`_. Be sure to
-get 32-, or 64-bit version depending on your system configuration.
+    OpenCL support is still minimal for now.
 
-Once CUDA is installed you can remove VisualStudio Express 2010.
+Install CUDA drivers
+^^^^^^^^^^^^^^^^^^^^
 
-Finally, grab the `Microsoft Visual C++ Compiler for Python 2.7
-<http://www.microsoft.com/en-us/download/details.aspx?id=44266>`_. It
-provides the now-obsolete compilers form Visual Studio 2008 that are
-required for compatibility with Python 2.7. To install the package for
-all users please:
+Follow `this link <https://developer.nvidia.com/cuda-downloads>`__
+to install the CUDA driver and the CUDA Toolkit.
 
-1. open an administrator's console (got to ``start``, then type ``cmd``,
-   right-click on the command prompt icon and select ``run as
-   administrator``)
-2. ``cd`` to your downloads directory and execute ``msiexec /i
-   VCForPython27.msi ALLUSERS=1``
+You must reboot the computer after the driver installation.
 
-The package will be installed to ``C:\Program Files
-(x86)\Common Files\Microsoft\Visual C++ for Python\9.0``.
+.. Installation of Theano and libgpuarray.
+.. include:: install_generic.inc
+    :start-after: .. _install_generic:
 
-Finally download the ``stdint.h`` header from
-`here <https://sourceforge.net/p/mspgcc/msp430-libc/ci/master/tree/include/stdint.h>`_ and save it as
-``C:\Program Files (x86)\Common Files\Microsoft\Visual C++ for
-Python\9.0\VC\include\stdint.h``.
+Instructions for other Python distributions (not recommended)
+=============================================================
 
-GCC
-###
+If you plan to use Theano with other Python distributions, these are generic guidelines to get
+a working environment:
 
-Theano C code compiler currently requires a GCC installation. We have
-used the build `TDM GCC <http://tdm-gcc.tdragon.net/>`_ which is
-provided for both 32- and 64-bit platforms. A few caveats to watch for
-during installation:
+    * Look for the mandatory requirements in the package manager's repositories of your distribution. Many
+      distributions come with ``pip`` package manager which use `PyPI repository <https://pypi.python.org/pypi>`__.
+      The required modules are Python (of course), NumPy, SciPy and a BLAS implementation (MKL or OpenBLAS).
+      Use the versions recommended at the top of this documentation.
+    * If the package manager provide a GCC compiler with the recommended version (see at top), install it. If not,
+      you could use the build `TDM GCC <http://tdm-gcc.tdragon.net/>`_ which is provided for both 32- and 64-bit
+      platforms. A few caveats to watch for during installation:
 
-1. Install to a directory without spaces (we have placed it in
+          1. Install to a directory without spaces (we have placed it in
              ``C:\SciSoft\TDM-GCC-64``)
-2. If you don't want to clutter your system PATH un-check ``add to
+          2. If you don't want to clutter your system PATH un-check ``add to
              path`` option.
-3. Enable OpenMP support by checking the option ``openmp support
+          3. Enable OpenMP support by checking the option ``openmp support
              option``.
 
-Scientific Python distribution
-##############################
-
-Recommended: Anaconda
-+++++++++++++++++++++
-
-ContinuumIO_ provides a free Python distribution for all 3 main desktop
-operating systems, including Windows 32-bit and 64-bit, and includes
-Theano and all of its dependencies. This is one of the the easiest ways
-to get Theano on Windows. Simply download and execute the installer from the
-`Anaconda download page <https://www.continuum.io/downloads>`__,
-and execute the following from the ``Anaconda Prompt``:
-
-.. _ContinuumIO: http://continuum.io
-
-.. code-block:: bash
-
-    $ conda install theano
-
-
-Alternative: WinPython
-++++++++++++++++++++++
-
-We highly recommend the Pierre Raybaut's `WinPython
-<http://winpython.sourceforge.net/>`_ distribution - it is compiled
-for both 32- and 64-bit systems, links against the fast `MKL
-<https://software.intel.com/en-us/intel-mkl>`_ BLAS
-implementation, supports installation of auxiliary packages from
-`Chris Gohlke <http://www.lfd.uci.edu/~gohlke/pythonlibs/>`_ and is
-free.
-
-WinPython also allows for a portable installation and doesn't clutter
-your main system PATH. We have installed it to
-``c:\SciSoft\WinPython-64bit-2.7.9.4``.
-
-Alternative in academia: EPD
-++++++++++++++++++++++++++++
-
-If you are working in academia, an easy way to install most of the
-dependencies is to install `Enthought Python Distribution (EPD) <http://enthought.com/products/epd.php>`_.
-If you are affiliated with a university (as student or employee), you can
-download the installation for free.
-EPD installation includes, in particular, Python (and the development headers),
-NumPy, SciPy, nose, sphinx, easy_install, pydot (but *not* Graphviz, which is
-necessary for it to work), g++, and the MKL
-implementation of blas.
-
-If you want to use the iPython shell, you should first try to import NumPy
-in it::
-
-    C:\Users\user>ipython
-    [...]
-    In [1]: import numpy
-
-If you see an error message telling you that ``DLL load failed``, that is
-probably due to a bug in the script launching ipython. If ``C:\SciSoft\Python27``
-is the directory where you installed EPD, edit
-``C:\SciSoft\Python27\Scripts\ipython.bat``, there should be a line saying::
-
-    set path="C:\SciSoft\Python27";%path%
-
-Remove the quotes around ``Python27``, leading to::
-
-    set path=C:\SciSoft\Python27;%path%
-
-Then, it should work in all new terminals.
-
-pip is not included in EPD, but you can simply install it with::
-
-    easy_install pip
-
-Alternative: Canopy
-+++++++++++++++++++
-
-Canopy is another software that installs all Theano dependencies.
-If you are affiliated with a university (as student or employee), you
-can download the installation for free.
-
-- Install Canopy x64, and update it to the latest version (`Help /
-  Software updates...`), as older Canopy versions have trouble installing
-  `pip`.
-- Then install `pip` from Canopy Package Manager.
-- In the Windows Prompt, type `pip install theano`.
-- In Canopy Package Manager, search and install packages "mingw 4.5.2" and "libpython 1.2"
-- (Needed only for Theano 0.6rc3 or earlier)
-  The "libpython 1.2" package installs files `libpython27.a` and `libmsvcr90.a` to
-  `C:\\Users\\<USER>\\AppData\\Local\\Enthought\\Canopy\\User\\libs`. Copy the two files to
-  `C:\\Users\\<USER>\\AppData\\Local\\Enthought\\Canopy\\App\\appdata\\canopy-1.0.0.1160.win-x86_64\libs`.
-- (Needed only for Theano 0.6rc3 or earlier) Set the Theano flags
-  ``blas.ldflags=-LC:\Users\<USER>\AppData\Local\Enthought\Canopy\App\appdata\canopy-1.0.0.1160.win-x86_64\Scripts -lmk2_core -lmk2_intel_thread -lmk2_rt``.
-
-
-
-Alternative: Python(x,y)
-++++++++++++++++++++++++
-
-If you do not have a commercial licence of EPD, and are not eligible to a free
-academic licence, and neither
-Python nor MinGW is installed on your computer, you can install most
-dependencies of Theano with `Python(x,y) <http://www.pythonxy.com>`__.
-It is a single installation
-file that contains additional packages like NumPy, SciPy, IPython, Matplotlib,
-MinGW, Nose, etc.
-Note however that there is no 64 bit version currently available.
-You can keep the default install options, except that the installation
-directory should not contain any blank space (in particular, do not install it
-into ``C:\Program Files``).
-
-Alternative: manual installation
-++++++++++++++++++++++++++++++++
-
-The following instructions provide steps for manual installation of all Theano
-dependencies.
-Note that it should be
-possible to run Theano with `Cygwin <http://www.cygwin.com/>`__ instead of
-MinGW, but this has not been tested yet.
-
-- For 32 bit MinGW: from `the MinGW files <http://sourceforge.net/projects/mingw/files/>`__,
-  download the latest version of the ``Automated MinGW Installer``
-  (``mingw-get-inst``) and install it (you should install all optional components,
-  except the Objective C and Ada compilers which are not needed).
-
-- For 64 bit MinGW (**note that manual installation for 64 bit is experimental**):
-  download the latest version of MinGW-w64 from the project's
-  `releases page <http://sourceforge.net/projects/mingw-w64/files/>`__, and extract
-  it for instance to ``C:\mingw64``. Also download MSYS from
-  `this page <http://sourceforge.net/projects/mingw-w64/files/External%20binary%20packages%20%28Win64%20hosted%29/MSYS%20%2832-bit%29/>`__
-  (although it is a 32-bit version of MSYS, this does not matter since it is only
-  a convenience tool). Extract MSYS into the same folder, so that, for instance, you
-  end up with ``C:\mingw64\msys``. Run ``C:\mingw64\msys\msys.bat`` and in the MSYS
-  shell, type
-
-   .. code-block:: bash
-
-       sh /postinstall/pi.sh
-
-  and answer the few questions so that MSYS is properly linked to your MinGW install.
-
-- It is recommended to set your MSYS home to be the same as your Windows home
-  directory. This will avoid inconsistent behavior between running Theano
-  in a Windows command prompt vs. a MSYS shell. One way to do this without
-  setting a global Windows ``HOME`` environment variable (which may affect
-  other programs) is to edit your ``msys.bat`` file (found e.g. under
-  ``C:\MinGW\msys\1.0`` or ``C:\mingw64\msys``) and add the following line at
-  the beginning (note that you may need to use e.g. Wordpad to edit this file,
-  since Notepad gets confused by Unix-style line breaks):
-
-    .. code-block:: bash
-
-        set HOME=%USERPROFILE%
-
-- If you do not have them already, install the latest versions of
-  `Python 2.x <http://www.python.org/download/windows>`__ and
-  corresponding `NumPy <http://sourceforge.net/projects/numpy/files/>`__
-  then `SciPy <http://sourceforge.net/projects/scipy/files/>`__
-  packages (simply use the executable installers).
-  Note that there are currently no official 64 bit releases of NumPy and
-  SciPy, but you can find unofficial builds
-  `here <http://www.lfd.uci.edu/~gohlke/pythonlibs/>`__.
-
-- Ensure that the Python installation directory and its ``Scripts``
-  sub-directory are in your system path. This may be done by
-  modifying the global ``PATH`` Windows environment variables, or by creating
-  a ``.profile`` file in your MinGW home, containing a line like
-  ``export PATH=$PATH:/c/Python27:/c/Python27/Scripts`` (note that the latter
-  will work only when you run Theano from an MSYS shell).
-
-- If you are installing the 64 bit version, you will need the following hack
-  to be able to compile Theano files with GCC (skip this step if you are using
-  the 32 bit version). In a temporary work directory, copy ``python27.dll``
-  (found in ``C:\\Windows\\System32``) as well as
-  `python27.def <http://wiki.cython.org/InstallingOnWindows?action=AttachFile&do=get&target=python27.def>`__.
-  Edit ``python27.def`` and replace ``Py_InitModule4`` with ``Py_InitModule4_64``.
-  Then open an MSYS shell, go to this temporary directory, and run:
-
-    .. code-block:: bash
-
-        dlltool --dllname python27.dll --def python27.def --output-lib libpython27.a
-
-  Finally, copy the libpython27.a file that was generated into your
-  ``C:\\Python27\\libs`` folder.
-
-- In order to run Theano's test-suite, you will need `nose
-  <http://nose.readthedocs.org/en/latest/>`__.
-  After unpacking its source code (you may use `7-zip
-  <http://www.7-zip.org/>`__), you can build and install it from within
-  its code directory by running the following command (either from a Windows
-  command prompt or an MSYS shell):
-
-    .. code-block:: bash
-
-        python setup.py install
-
-
-
-
-
-Configuring the Environment
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-At this point, you should have installed all Theano dependencies.
-By default neither Python, GCC, nor Visual Studio was added to the
-PATH. Save the following shell script as ``c:\scisoft\env.bat`` to
-configure the system path:
-
-.. code-block:: none
-
-   REM configuration of paths
-   set VSFORPYTHON="C:\Program Files (x86)\Common Files\Microsoft\Visual C++ for Python\9.0"
-   set SCISOFT=%~dp0
-
-   REM add tdm gcc stuff
-   set PATH=%SCISOFT%\TDM-GCC-64\bin;%SCISOFT%\TDM-GCC-64\x86_64-w64-mingw32\bin;%PATH%
-
-   REM add winpython stuff
-   CALL %SCISOFT%\WinPython-64bit-2.7.9.4\scripts\env.bat
-
-   REM configure path for msvc compilers
-   REM for a 32 bit installation change this line to
-   REM CALL %VSFORPYTHON%\vcvarsall.bat
-   CALL %VSFORPYTHON%\vcvarsall.bat amd64
-
-   REM return a shell
-   cmd.exe /k
-
-The script assumes that you installed WinPython distribution, update the winpython line otherwise.
-For a 32 bit installation please change the indicated line to load
-32-bit Microsoft Compilers.
-
-You can access the Python shell by double-clicking on
-``c:\scisoft\env.bat``. Please do so, and verify that the following
-programs are found:
-
-1. where gcc
-2. where gendef
-3. where cl
-4. where nvcc
-
-Finally we need to create a link library for GCC. Open up the Python
-shell and ``cd`` to ``c:\SciSoft``. Then execute:
-
-.. code-block:: none
-
-   gendef WinPython-64bit-2.7.9.4\python-2.7.9.amd64\python27.dll
-
-   dlltool --dllname python27.dll --def python27.def --output-lib WinPython-64bit-2.7.9.4\python-2.7.9.amd64\libs\libpython27.a
-
-Installing Theano
-~~~~~~~~~~~~~~~~~
-
-Once the dependencies are installed, you can download and install
-Theano. We have found that in the long run, the Git install is the
-most useful, because you can update it with a single ``git pull``
-command. Therefore we recommend it. However, a manual install without
-Git is also possible.
-
-
-Git Install
-###########
-
-Theano is hosted on GitHub, you need Git to download it. For Windows,
-download and install the `MSYSGIT <http://msysgit.github.io/>`_ build.
-Open up the `Git Shell` in the directory in which you want to install
-Theano. For the bleeding-edge version execute
-
-.. code-block:: bash
-
-  git clone https://github.com/Theano/Theano.git
-
-For the latest stable release 0.7 (as of March 2015) run instead:
-
-.. code-block:: bash
-
-  git clone https://github.com/Theano/Theano.git --branch rel-0.7
-
-Either way, a folder `Theano` will be created with the library
-downloaded to it.
-
-
-Manual Installation
-###################
-
-To get the latest bleeding edge version got to `Theano on GitHub
-<https://github.com/Theano/Theano>`_ and download the `latest zip
-<https://github.com/Theano/Theano/archive/master.zip>`_. Then unzip it
-somewhere.
-
-Alternatively, you can check the latest release release 0.7 (as of March
-2015) by going to
-https://github.com/Theano/Theano/releases/tag/rel-0.7 and
-downloading the `zip
-<https://github.com/Theano/Theano/archive/rel-0.7.zip>`_.
-
-Configuring Theano
-##################
-
-Once you have installed Theano, open the Python Shell
-(e.g. ``c:\scisoft\env.bat`` if you follow the installation directories
-from this tutorial) and ``cd`` to it. Then run::
-
-  python setup.py develop
-
-this step will add the Theano directory to you ``PYTHON_PATH``
-environment variable.
-
-At this stage you can check whether Theano works and is able to
-compile C code for CPU execution.
-
-Create a test file containing:
-
-.. testcode::
-
-   import numpy as np
-   import time
-   import theano
-   A = np.random.rand(1000,10000).astype(theano.config.floatX)
-   B = np.random.rand(10000,1000).astype(theano.config.floatX)
-   np_start = time.time()
-   AB = A.dot(B)
-   np_end = time.time()
-   X,Y = theano.tensor.matrices('XY')
-   mf = theano.function([X,Y],X.dot(Y))
-   t_start = time.time()
-   tAB = mf(A,B)
-   t_end = time.time()
-   print("NP time: %f[s], theano time: %f[s] (times should be close when run on CPU!)" %(
-                                              np_end-np_start, t_end-t_start))
-   print("Result difference: %f" % (np.abs(AB-tAB).max(), ))
-
-.. testoutput::
-   :hide:
-   :options: +ELLIPSIS
-
-   NP time: ...[s], theano time: ...[s] (times should be close when run on CPU!)
-   Result difference: ...
-
-.. code-block:: none
-
-   NP time: 1.480863[s], theano time: 1.475381[s] (times should be close when run on CPU!)
-   Result difference: 0.000000
-
-Then run it. It should execute without problems and the Theano function
-should run at a speed similar to the regular NumPy
-multiplication. (Both Numpy and Theano should call the same BLAS
-routine for matrix multiplication)
-
-
-Configure Theano for GPU use
-############################
-
-Install `libgpuarray <http://deeplearning.net/software/libgpuarray/installation.html>`_ if you have not already done so.
-
-Theano can be configured with a ``.theanorc`` text file (or
-``.theanorc.txt``, whichever is easier for you to create under
-Windows). It should be placed in the directory pointed to by the
-``%USERPROFILE%`` variable. Please note, that WinPython changes it to
-``WinPythonDir\settings`` (so in our system this corresponds to
-``c:\scisoft\WinPython-64bit-2.7.9.4\settings``.
-
-To use the GPU please write the following configuration file:
-
-.. code-block:: cfg
-
-   [global]
-   device = cuda
-   floatX = float32
-
-   [nvcc]
-   flags = --use-local-env  --cl-version=2008
-
-Rerun the simple test file and verify that it runs. Depending on you
-GPU, the theano function should run on the GPU much faster than the
-CPU matrix multiplication performed by NumPy.
-You can also find additional test code and useful GPU tips on the
-:ref:`using_gpu` page.
-
-Running Theano's test-suite
-###########################
-
-Currently, due to memory fragmentation issue in Windows, the
-test-suite breaks at some point when using ``theano-nose``, with many error
-messages looking
-like: ``DLL load failed: Not enough storage is available to process this
-command``. As a workaround, you can instead run:
-
-    .. code-block:: bash
-
-        theano-nose --batch
-
-This will run tests in batches of 100, which should avoid memory errors.
-Note that this script calls ``nosetests``, which may require being run from
-within an MSYS shell if you installed Nose manually as described above.
-
-.. note::
-
-    In Theano versions <= 0.5, ``theano-nose`` was not included.  If you
-    are working with such a version, you can call this command instead:
-
-    .. code-block:: bash
-
-        python theano/tests/run_tests_in_batch.py
-
-Compiling a faster BLAS
-~~~~~~~~~~~~~~~~~~~~~~~
-
-If you installed Python through WinPython or EPD, Theano will automatically
-link with the MKL library, so you should not need to compile your own BLAS.
-
-.. note::
-
-   The instructions below have not been tested in a Windows 64 bit environment.
-
-If you want a faster and/or multi-threaded BLAS library, you can
-compile OpenBLAS (ATLAS may work too, but was not tested, and is
-usually reported to be slower and more difficult to compile -- especially
-on Windows).
-OpenBLAS can be downloaded as a zip file from
-`its website <http://xianyi.github.io/OpenBLAS/>`__
-(we tested v0.2.6).
-To compile it, you will also need MSYS and wget (installation steps are
-described below).
-
-If you already have a full install of MinGW, you should
-have MSYS included in it, and thus should be able to start a MinGW shell.
-If that is the case, you can skip the following MSYS installation steps.
-Note that these steps were written for Python(x,y), but should also work
-for other bundle Python distributions like EPD (changing paths accordingly,
-for instance in EPD 7.3.2 the MinGW folder is
-``EPD7.3.2\EGG-INFO\mingw\usr\i686-w64-mingw32``).
-To install MSYS on top of the MinGW installation included within Python(x,y),
-do as follows:
-
-- Download the `mingw-get command-line installer binary
-  <http://sourceforge.net/projects/mingw/files/Installer/mingw-get/>`__.
-
-- Unpack its content into your ``pythonxy\mingw`` directory.
-
-- In a prompt (``cmd``), install MSYS with
-
-    .. code-block:: bash
-
-        mingw-get install msys-base
-
-  If ``mingw-get`` cannot be found automatically, just navigate first into the
-  folder were it was extracted (it is found in the ``bin`` subfolder).
-
-- Edit ``pythonxy\mingw\msys\1.0\msys.bat`` (e.g. in Wordpad) and add as first
-  line ``set HOME=%USERPROFILE%``. Then create an easily accessible shortcut
-  (e.g. on your desktop) to this file, run it and within the MSYS
-  console, run the MSYS post-install script:
-
-    .. code-block:: bash
-
-        /postinstall/pi.sh
-
-  It will ask for your MinGW installation directory (e.g.
-  ``c:/pythonxy/mingw``; note the forward slashes).
-
-Once you have a working MinGW/MSYS shell environment, you can go on as
-follows:
-
-  a) Install ``wget`` by running the setup program you can download on the
-     `wget website <http://gnuwin32.sourceforge.net/packages/wget.htm>`__.
-     Note that this setup does not add ``wget`` into the system PATH, so you
-     will need to modify the ``PATH`` environment variable accordingly (either in
-     Windows or in a ``.profile`` startup file in your MinGW home). Once this is done,
-     type ``wget --version`` in a MinGW shell to verify that it is running
-     properly. Note also that if you are behind a proxy, you should set up your
-     ``HTTP_PROXY`` environment variable, or use a custom ``wgetrc`` config file
-     for wget to be able to download files.
-
-  b) Unzip OpenBLAS and, in a MinGW shell, go into the corresponding directory.
-
-  c) Compile OpenBLAS with:
-
-    .. code-block:: bash
-
-      quickbuild.win32 1>log.txt 2>err.txt
-
-    (use ``quickbuild.win64`` for 64-bit Windows).
-    Compilation can take a while, so now is a good time to take a break.
-    When it is done, you should have ``libopenblas.dll`` in your OpenBLAS
-    folder. If that is not the case, check the ``err.txt`` log for build errors.
-
-  d) Make sure that ``libopenblas.dll`` is in a folder that is in your ``PATH``.
-
-  e) Modify your .theanorc (or .theanorc.txt) with
-     ``ldflags = -LX:\\YYY\\ZZZ -lopenblas`` where ``X:\\YYY\\ZZZ`` is the path
-     to the folder containing ``libopenblas.dll``.
-     This setting can also be changed in Python for testing purpose (in which
-     case it will remain only for the duration of your Python session):
-
-    .. code-block:: python
-
-        theano.config.blas.ldflags = "-LX:\\YYY\\YYY -lopenblas"
-
-  f) To test the BLAS performance, you can run the script
-     ``theano/misc/check_blas.py``.
-     Note that you may control the number of threads used by OpenBLAS with
-     the ``OPENBLAS_NUM_THREADS`` environment variable (default behavior is to use
-     all available cores).
-     Here are some performance results on an Intel Core2 Duo 1.86 GHz,
-     compared to using NumPy's BLAS or the un-optimized standard BLAS
-     (compiled manually from its source code).
-     Note that we report here results for GotoBLAS2 which is the ancestor of
-     OpenBLAS (this benchmark still needs to be updated with OpenBLAS results):
-
-         * GotoBLAS2 (2 threads): 16s
-         * NumPy (1 thread): 48s
-         * Standard BLAS (un-optimized, 1 thread): 166s
-
-     Conclusions:
-        * The unoptimized standard BLAS is very slow and should not be used.
-        * The Windows binaries of NumPy were compiled with ATLAS and are surprisingly fast.
-        * GotoBLAS2 is even faster, in particular if you can use multiple cores.
-
-.. note::
-
-   If you get a ``DLL load failed`` error message, it typically means that
-   a required DLL was not found in the PATH. If it happens only when you are
-   using OpenBLAS, it means it is either ``libopenblas.dll`` itself or one of its
-   dependencies. In the case where it is a dependency, you can use the
-   `Dependency Walker <http://www.dependencywalker.com/>`__ utility to figure out
-   which one.
+    * Install CUDA with the same instructions as above.
+    * Install the latest, development version of libgpuarray following the
+      `Step-by-step instructions <http://deeplearning.net/software/libgpuarray/installation.html#step-by-step-install>`__.

doc/internal/how_to_release.txt

@@ -153,7 +153,7 @@ For final releases, send the e-mail to the following mailing lists:
 * theano-users
 * theano-announce
 * numpy-discussion@scipy.org
-* scipy-user@scipy.org
+* scipy-user@python.org
 * G+, Scientific Python: https://plus.google.com/communities/108773711053400791849
 
 For release candidates, only e-mail:

doc/requirements.inc

@@ -7,14 +7,21 @@ Requirements
 
 .. _BLAS: http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms
 .. _Python: http://www.python.org/
+.. _LaTeX: http://www.latex-project.org/
+.. _dvipng: http://savannah.nongnu.org/projects/dvipng/
+.. _NVIDIA CUDA drivers and SDK: http://developer.nvidia.com/object/gpucomputing.html
+.. _libgpuarray: http://deeplearning.net/software/libgpuarray/installation.html
+.. _pycuda: https://mathema.tician.de/software/pycuda/
+.. _skcuda: http://scikit-cuda.readthedocs.io/en/latest/
 
-    Python_ >= 2.7 or >= 3.3 The development package (python-dev or
+    Python_ == 2.7 or ( >= 3.3 and <= 3.5 )
+        The development package (python-dev or
         python-devel on most Linux distributions) is recommended (see
         just below). Python 2.4 was supported up to and including the
         release 0.6. Python 2.6 was supported up to and including the
         release 0.8.2. Python 3 is supported past the 3.3 release.
 
-    `NumPy <http://numpy.scipy.org/>`_ >= 1.9.1 < 1.11.1
+    `NumPy <http://numpy.scipy.org/>`_ >= 1.9.1 <= 1.12
         Earlier versions could work, but we don’t test it.
 
     `SciPy <http://scipy.org>`_ >= 0.14 < 0.17.1
@@ -42,10 +49,9 @@ Requirements
         **Highly recommended** Required for GPU code generation/execution on NVIDIA gpus. See instruction below.
 
     `libgpuarray`_
-        Required for GPU/CPU code generation on CUDA and OpenCL devices (see: :ref:`gpuarray`.)
+        Required for GPU/CPU code generation on CUDA and OpenCL devices (see: :ref:`gpuarray`).
 
     `pycuda`_ and `skcuda`_
-
         Required for some extra operations on the GPU like fft and
         solvers. We use them to wrap cufft and cusolver. Quick install
         ``pip install pycuda scikit-cuda``. For cuda 8, the dev
@@ -63,7 +69,9 @@ Follow this `link <http://conda.pydata.org/miniconda.html>`__ to install Minicon
 
 .. note::
 
-    If you want fast compiled code (recommended), make sure you have g++ (Windows/Linux) or Clang (OS X) installed.
+    If you want fast compiled code (recommended), make sure you have |CompilerName| installed.
+
+.. install_requirements_and_optional_packages
 
 Install requirements and optional packages
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,9 +117,4 @@ Install and configure the GPU drivers (recommended)
     * add a ``cuda.root`` flag to :envvar:`THEANO_FLAGS`, as in ``THEANO_FLAGS='cuda.root=/path/to/cuda/root'``, or
     * add a [cuda] section to your .theanorc file containing the option ``root = /path/to/cuda/root``.
 
-.. _LaTeX: http://www.latex-project.org/
-.. _dvipng: http://savannah.nongnu.org/projects/dvipng/
-.. _NVIDIA CUDA drivers and SDK: http://developer.nvidia.com/object/gpucomputing.html
-.. _libgpuarray: http://deeplearning.net/software/libgpuarray/installation.html
-.. _pycuda: https://mathema.tician.de/software/pycuda/
-.. _skcuda: http://scikit-cuda.readthedocs.io/en/latest/
+

doc/requirements.txt

 .. |PlatformCompiler| replace:: ``g++`` (Linux and Windows), ``clang`` (OS X)
 
+.. |CompilerName| replace:: ``g++`` (Windows/Linux) or ``Clang`` (OS X)
 .. include:: requirements.inc