Metadata-Version: 1.1
Name: Theano
Version: 0.9.0
Summary: Optimizing compiler for evaluating mathematical expressions on CPUs and GPUs.
Home-page: http://deeplearning.net/software/theano/
Author: LISA laboratory, University of Montreal
Author-email: theano-dev@googlegroups.com
License: BSD
Description: Theano is a Python library that allows you to define, optimize, and efficiently evaluate mathematical expressions involving multi-dimensional arrays. It is built on top of NumPy_. Theano 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).
         * **efficient symbolic differentiation:** Theano can compute derivatives for functions of one or many inputs.
         * **speed and stability optimizations:** avoid nasty bugs when computing expressions such as log(1 + exp(x)) for large values of x.
         * **dynamic C code generation:** evaluate expressions faster.
         * **extensive unit-testing and self-verification:** includes tools for detecting and diagnosing bugs and/or potential problems.
        
        Theano has been powering large-scale computationally intensive scientific
        research since 2007, but it is also approachable enough to be used in the
        classroom (IFT6266 at the University of Montreal).
        
        .. _NumPy: http://numpy.scipy.org/
        
        
        =============
        Release Notes
        =============
        
        
        Theano 0.9.0 (20th of March, 2017)
        ==================================
        
        This is a final release of Theano, version ``0.9.0``, with a lot of
        new features, interface changes, improvements and bug fixes.
        
        We recommend that everybody update to this version.
        
        Highlights (since 0.8.0):
         - Better Python 3.5 support
         - Better numpy 1.12 support
         - Conda packages for Mac, Linux and Windows
         - Support newer Mac and Windows versions
         - More Windows integration:
        
           - Theano scripts (``theano-cache`` and ``theano-nose``) now works on Windows
           - Better support for Windows end-lines into C codes
           - Support for space in paths on Windows
        
         - Scan improvements:
        
           - More scan optimizations, with faster compilation and gradient computation
           - Support for checkpoint in scan (trade off between speed and memory usage, useful for long sequences)
           - Fixed broadcast checking in scan
        
         - Graphs improvements:
        
           - More numerical stability by default for some graphs
           - Better handling of corner cases for theano functions and graph optimizations
           - More graph optimizations with faster compilation and execution
           - smaller and more readable graph
        
         - New GPU back-end:
        
           - Removed warp-synchronous programming to get good results with newer CUDA drivers
           - More pooling support on GPU when cuDNN isn't available
           - Full support of ignore_border option for pooling
           - Inplace storage for shared variables
           - float16 storage
           - Using PCI bus ID of graphic cards for a better mapping between theano device number and nvidia-smi number
           - Fixed offset error in ``GpuIncSubtensor``
        
         - Less C code compilation
         - Added support for bool dtype
         - Updated and more complete documentation
         - Bug fixes related to merge optimizer and shape inference
         - Lot of other bug fixes, crashes fixes and warning improvements
        
        A total of 123 people contributed to this release since 0.8.0, see list below.
        
        Interface changes:
         - Merged ``CumsumOp/CumprodOp`` into ``CumOp``
         - In MRG module:
        
           - Replaced method ``multinomial_wo_replacement()`` with new method ``choice()``
           - Random generator now tries to infer the broadcast pattern of its output
        
         - New pooling interface
         - Pooling parameters can change at run time
         - Moved ``softsign`` out of sandbox to ``theano.tensor.nnet.softsign``
         - Using floatX dtype when converting empty list/tuple
         - ``Roll`` make the shift be modulo the size of the axis we roll on
         - ``round()`` default to the same as NumPy: half_to_even
        
        Convolution updates:
         - Support of full and half modes for 2D and 3D convolutions including in ``conv3d2d``
         - Allowed pooling of empty batch
         - Implement ``conv2d_transpose`` convenience function
         - Multi-cores convolution and pooling on CPU
         - New abstract 3d convolution interface similar to the 2d convolution interface
         - Dilated convolution
        
        
        GPU:
         - cuDNN: support versoin 5.1 and wrap batch normalization (2d and 3d) and RNN functions
         - Multiple-GPU, synchrone update (via platoon, use NCCL)
         - Gemv(matrix-vector product) speed up for special shape
         - cublas gemv workaround when we reduce on an axis with a dimensions size of 0
         - Warn user that some cuDNN algorithms may produce unexpected results in certain environments
           for convolution backward filter operations
         - ``GPUMultinomialFromUniform`` op now supports multiple dtypes
         - Support for ``MaxAndArgMax`` for some axis combination
         - Support for solve (using cusolver), erfinv and erfcinv
         - Implemented ``GpuAdvancedSubtensor``
        
        New features:
         - ``OpFromGraph`` now allows gradient overriding for every input
         - Added Abstract Ops for batch normalization that use cuDNN when available and pure Theano CPU/GPU alternatives otherwise
         - Added gradient of solve, tensorinv (CPU), tensorsolve (CPU), searchsorted (CPU), DownsampleFactorMaxGradGrad (CPU)
         - Added Multinomial Without Replacement
         - Allowed partial evaluation of compiled function
         - More Rop support
         - Indexing support ellipsis: ``a[..., 3]```, ``a[1,...,3]``
         - Added ``theano.tensor.{tensor5,dtensor5, ...}``
         - compiledir_format support device
         - Added New Theano flag ``conv.assert_shape`` to check user-provided shapes at runtime (for debugging)
         - Added new Theano flag ``cmodule.age_thresh_use``
         - Added new Theano flag ``cuda.enabled``
         - Added new Theano flag ``nvcc.cudafe`` to enable faster compilation and import with old CUDA back-end
         - Added new Theano flag ``print_global_stats`` to print some global statistics (time spent) at the end
         - Added new Theano flag ``profiling.ignore_first_call``, useful to profile the new gpu back-end
         - remove ProfileMode (use Theano flag ``profile=True`` instead)
        
        
        Others:
         - Split op now has C code for CPU and GPU
         - ``theano-cache list`` now includes compilation times
         - Speed up argmax only on GPU (without also needing the max)
         - More stack trace in error messages
         - Speed up cholesky grad
         - ``log(sum(exp(...)))`` now get stability optimized
        
        
        Other more detailed changes:
         - Added Jenkins (gpu tests run on pull requests in addition to daily buildbot)
         - Removed old benchmark directory and other old files not used anymore
         - Use of 64-bit indexing in sparse ops to allow matrix with more then 2\ :sup:`31`\ -1 elements
         - Allowed more then one output to be an destructive inplace
         - More support of negative axis
         - Added the keepdims parameter to the norm function
         - Make scan gradient more deterministic
        
        Commiters since 0.8.0:
         - Frederic Bastien
         - Arnaud Bergeron
         - Pascal Lamblin
         - Steven Bocco
         - Ramana Subramanyam
         - Simon Lefrancois
         - Gijs van Tulder
         - Benjamin Scellier
         - khaotik
         - Chiheb Trabelsi
         - Chinnadhurai Sankar
         - Cesar Laurent
         - Reyhane Askari
         - Mohammad Pezeshki
         - Alexander Matyasko
         - Alexandre de Brebisson
         - Mathieu Germain
         - Nan Rosemary Ke
         - Pierre Luc Carrier
         - Olivier Mastropietro
         - Thomas George
         - Saizheng Zhang
         - Iulian Vlad Serban
         - Francesco Visin
         - Caglar
         - Faruk Ahmed
         - Harm de Vries
         - Samira Shabanian
         - Vincent Dumoulin
         - Nicolas Ballas
         - Jakub Sygnowski
         - Jan Schlüter
         - Samira Ebrahimi Kahou
         - Mikhail Korobov
         - Fei Wang
         - Kv Manohar
         - Jesse Livezey
         - Kelvin Xu
         - Matt Graham
         - Ruslana Makovetsky
         - Sina Honari
         - Bryn Keller
         - Ciyong Chen
         - Vitaliy Kurlin
         - Zhouhan LIN
         - Gokula Krishnan
         - Kumar Krishna Agrawal
         - Ozan Çağlayan
         - Vincent Michalski
         - affanv14
         - Amjad Almahairi
         - Ray Donnelly
         - Tim Cooijmans
         - happygds
         - mockingjamie
         - Christos Tsirigotis
         - Florian Bordes
         - Ilya Kulikov
         - RadhikaG
         - Taesup (TS) Kim
         - Ying Zhang
         - Anton Chechetka
         - Karthik Karanth
         - Kirill Bobyrev
         - Rebecca N. Palmer
         - Yang Zhang
         - Yaroslav Ganin
         - Jonas Degrave
         - Liwei Cai
         - Lucas Beyer
         - Michael Harradon
         - Morgan Stuart
         - Tim Gasper
         - Xavier Bouthillier
         - p
         - texot
         - Andrés Gottlieb
         - Ben Poole
         - Bhavishya Pohani
         - Carl Thomé
         - David Bau
         - Dimitar Dimitrov
         - Evelyn Mitchell
         - Fei Zhan
         - Fuchai
         - Fábio Perez
         - Gennadiy Tupitsin
         - Gilles Louppe
         - Greg Ciccarelli
         - He
         - Huan Zhang
         - Kaixhin
         - Kevin Keraudren
         - Maltimore
         - Marc-Alexandre Cote
         - Marco
         - Marius F. Killinger
         - Martin Drawitsch
         - Maxim Kochurov
         - Micah Bojrab
         - Neil
         - Nizar Assaf
         - Rithesh Kumar
         - Rizky Luthfianto
         - Robin Millette
         - Roman Ring
         - Sander Dieleman
         - Sebastin Santy
         - Shawn Tan
         - Wazeer Zulfikar
         - Wojciech Głogowski
         - Yann N. Dauphin
         - gw0 [http://gw.tnode.com/]
         - hexahedria
         - hsintone
         - jakirkham
         - joncrall
         - root
         - superantichrist
         - tillahoffmann
         - valtron
         - wazeerzulfikar
         - you-n-g
        
Keywords: theano math numerical symbolic blas numpy gpu autodiff differentiation
Platform: Windows
Platform: Linux
Platform: Solaris
Platform: Mac OS-X
Platform: Unix
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python
Classifier: Topic :: Software Development :: Code Generators
Classifier: Topic :: Software Development :: Compilers
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: Operating System :: Unix
Classifier: Operating System :: MacOS
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
