├── .circleci
    ├── artifact_path
    └── config.yml
├── .coveragerc
├── .gitignore
├── .mailmap
├── .travis.yml
├── .zenodo.json
├── LICENSE
├── MANIFEST.in
├── Makefile
├── PLANS.md
├── README.rst
├── doc
    ├── Makefile
    ├── README.md
    ├── _themes
    │   └── sphinx_rtd_theme
    │   │   ├── __init__.py
    │   │   ├── breadcrumbs.html
    │   │   ├── footer.html
    │   │   ├── layout.html
    │   │   ├── layout_old.html
    │   │   ├── search.html
    │   │   ├── searchbox.html
    │   │   ├── static
    │   │       ├── css
    │   │       │   ├── badge_only.css
    │   │       │   ├── badge_only.css.map
    │   │       │   ├── theme.css
    │   │       │   └── theme.css.map
    │   │       ├── fonts
    │   │       │   ├── FontAwesome.otf
    │   │       │   ├── Inconsolata-Bold.ttf
    │   │       │   ├── Inconsolata-Regular.ttf
    │   │       │   ├── Lato-Bold.ttf
    │   │       │   ├── Lato-Regular.ttf
    │   │       │   ├── RobotoSlab-Bold.ttf
    │   │       │   ├── RobotoSlab-Regular.ttf
    │   │       │   ├── fontawesome-webfont.eot
    │   │       │   ├── fontawesome-webfont.svg
    │   │       │   ├── fontawesome-webfont.ttf
    │   │       │   └── fontawesome-webfont.woff
    │   │       └── js
    │   │       │   ├── modernizr.min.js
    │   │       │   └── theme.js
    │   │   ├── theme.conf
    │   │   └── versions.html
    ├── api.rst
    ├── cheatsheet.rst
    ├── citation.rst
    ├── conf.py
    ├── contributing.rst
    ├── index.rst
    ├── install.rst
    ├── resources.rst
    ├── start.rst
    ├── tutorial.rst
    └── whats_new.rst
├── examples
    ├── README.txt
    ├── community_crime.csv
    ├── plot_community_crime.py
    ├── plot_glm_retinal_ganglia.py
    ├── plot_group_lasso.py
    └── plot_tikhonov.py
├── paper
    ├── paper.bib
    └── paper.md
├── pyglmnet-logo.png
├── pyglmnet
    ├── __init__.py
    ├── base.py
    ├── benchmarks.py
    ├── datasets.py
    ├── externals
    │   ├── README
    │   ├── __init__.py
    │   └── sklearn
    │   │   ├── __init__.py
    │   │   ├── exceptions.py
    │   │   └── utils
    │   │       ├── __init__.py
    │   │       ├── config.py
    │   │       ├── extmath.py
    │   │       ├── fixes.py
    │   │       └── validation.py
    ├── metrics.py
    ├── pyglmnet.py
    └── utils.py
├── requirements.txt
├── setup.cfg
├── setup.py
└── tests
    ├── __init__.py
    ├── test_metrics.py
    └── test_pyglmnet.py


/.circleci/artifact_path:
--------------------------------------------------------------------------------
1 | 0/html/index.html
2 | 


--------------------------------------------------------------------------------
/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | jobs:
 3 |     build_docs:
 4 |         docker:
 5 |             - image: circleci/python:3.7.0-stretch-node-browsers
 6 |         steps:
 7 |             - checkout
 8 |             - run:
 9 |                 name: Install miniconda
10 |                 command: |
11 |                   wget -q http://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh -O ~/miniconda.sh;
12 |                   chmod +x ~/miniconda.sh;
13 |                   ~/miniconda.sh -b -p ~/miniconda;
14 |                   echo "export PATH=~/miniconda/bin:$PATH" >> $BASH_ENV;
15 |             - run:
16 |                 name: Setup Python environment
17 |                 command: |
18 |                     conda update --yes conda
19 |                     conda create -n testenv --yes python=3.7
20 |                     source activate testenv
21 |                     pip install --upgrade pip -q
22 |                     pip install sphinx matplotlib coverage Pillow -q
23 |                     pip install sphinx-gallery -q
24 |                     pip install scipy scikit-learn pandas -q
25 |                     pip install -e .
26 |                     pip install sphinx_bootstrap_theme numpydoc -q
27 |                     pip install -e git+http://github.com/KordingLab/spykes.git#egg=spykes
28 |                     python -c "import pyglmnet; pyglmnet.datasets.fetch_rgc_spike_trains(accept_rgcs_license=True);"
29 |                     python --version
30 |                     pip list
31 |             - run:
32 |                 name: Build the documentation
33 |                 command: |
34 |                     source activate testenv
35 |                     cd doc && make html
36 |                 no_output_timeout: 30m
37 |             - store_artifacts:
38 |                 path: doc/_build/html/
39 |                 destination: html
40 | 
41 | workflows:
42 |   version: 2
43 |   search_build:
44 |     jobs:
45 |       - build_docs
46 | 


--------------------------------------------------------------------------------
/.coveragerc:
--------------------------------------------------------------------------------
 1 | [run]
 2 | branch = True
 3 | source = pyglmnet
 4 | include = */pyglmnet/*
 5 | omit =
 6 |     */setup.py
 7 |     */pyglmnet/benchmarks.py
 8 |     */pyglmnet/datasets.py
 9 |     */pyglmnet/externals/*
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Created by .ignore support plugin (hsz.mobi)
  2 | ### JetBrains template
  3 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
  4 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
  5 | 
  6 | # User-specific stuff:
  7 | .idea/workspace.xml
  8 | .idea/tasks.xml
  9 | .idea/dictionaries
 10 | .idea/vcs.xml
 11 | .idea/jsLibraryMappings.xml
 12 | 
 13 | # Sensitive or high-churn files:
 14 | .idea/dataSources.ids
 15 | .idea/dataSources.xml
 16 | .idea/dataSources.local.xml
 17 | .idea/sqlDataSources.xml
 18 | .idea/dynamic.xml
 19 | .idea/uiDesigner.xml
 20 | .pypirc
 21 | 
 22 | 
 23 | # Gradle:
 24 | .idea/gradle.xml
 25 | .idea/libraries
 26 | 
 27 | .idea
 28 | 
 29 | # Mongo Explorer plugin:
 30 | .idea/mongoSettings.xml
 31 | 
 32 | ## File-based project format:
 33 | *.iws
 34 | 
 35 | ## Plugin-specific files:
 36 | 
 37 | # IntelliJ
 38 | /out/
 39 | 
 40 | # mpeltonen/sbt-idea plugin
 41 | .idea_modules/
 42 | 
 43 | # JIRA plugin
 44 | atlassian-ide-plugin.xml
 45 | 
 46 | # Crashlytics plugin (for Android Studio and IntelliJ)
 47 | com_crashlytics_export_strings.xml
 48 | crashlytics.properties
 49 | crashlytics-build.properties
 50 | fabric.properties
 51 | ### Python template
 52 | # Byte-compiled / optimized / DLL files
 53 | __pycache__/
 54 | *.py[cod]
 55 | *$py.class
 56 | 
 57 | # C extensions
 58 | *.so
 59 | 
 60 | # Distribution / packaging
 61 | .Python
 62 | env/
 63 | build/
 64 | develop-eggs/
 65 | dist/
 66 | downloads/
 67 | eggs/
 68 | .eggs/
 69 | lib/
 70 | lib64/
 71 | parts/
 72 | sdist/
 73 | var/
 74 | *.egg-info/
 75 | .installed.cfg
 76 | *.egg
 77 | 
 78 | # PyInstaller
 79 | #  Usually these files are written by a python script from a template
 80 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 81 | *.manifest
 82 | *.spec
 83 | 
 84 | # Installer logs
 85 | pip-log.txt
 86 | pip-delete-this-directory.txt
 87 | 
 88 | # Unit test / coverage reports
 89 | htmlcov/
 90 | .tox/
 91 | .coverage
 92 | .coverage.*
 93 | .cache
 94 | nosetests.xml
 95 | coverage.xml
 96 | *,cover
 97 | .hypothesis/
 98 | 
 99 | # Translations
100 | *.mo
101 | *.pot
102 | 
103 | # Django stuff:
104 | *.log
105 | local_settings.py
106 | 
107 | # Flask instance folder
108 | instance/
109 | 
110 | # Scrapy stuff:
111 | .scrapy
112 | 
113 | # Sphinx documentation
114 | docs/_build/
115 | 
116 | # PyBuilder
117 | target/
118 | 
119 | # IPython Notebook
120 | .ipynb_checkpoints
121 | 
122 | # pyenv
123 | .python-version
124 | 
125 | # celery beat schedule file
126 | celerybeat-schedule
127 | 
128 | # dotenv
129 | .env
130 | 
131 | # virtualenv
132 | venv/
133 | ENV/
134 | 
135 | # Spyder project settings
136 | .spyderproject
137 | 
138 | # Rope project settings
139 | .ropeproject
140 | ### IPythonNotebook template
141 | # Temporary data
142 | .ipynb_checkpoints/
143 | 
144 | # Other misc files
145 | todo.md
146 | 


--------------------------------------------------------------------------------
/.mailmap:
--------------------------------------------------------------------------------
 1 | Aid Idrizović <idrizovicaid@gmail.com>
 2 | Beibin Li <BeibinLi@users.noreply.github.com>
 3 | Chris Rodgers <xrodgers@gmail.com>
 4 | Daniel E. Acuna <daniel.ernesto.acuna@gmail.com> Daniel Acuna <daniel.acuna@northwestern.edu>
 5 | Drew Harris <drew.harris.nz@gmail.com>
 6 | Eva Dyer <evadevah@gmail.com>
 7 | Giovanni De Toni <giovanni.det@gmail.com>
 8 | Hugo Fernandes <hugoguh@gmail.com> hugoguh <hugoguh@gmail.com>
 9 | Hugo Fernandes <hugoguh@gmail.com> hugoguh <hugo-fernandes@northwestern.edu>
10 | Mainak Jas <mainakjas@gmail.com> <jasmainak@users.noreply.github.com>
11 | Mainak Jas <mainakjas@gmail.com> <mainak.jas@telecom-paristech.fr>
12 | Matthew Antalek <matthew.antalek@gmail.com> Matthew Antalek <matthew.antalek@northwestern.edu>
13 | Matthew Antalek <matthew.antalek@gmail.com> Matt Antalek <matthew.antalek@gmail.com>
14 | Mayank Agrawal <mayankagrawal96@gmail.com> timshell <magrawa1@swarthmore.edu>
15 | Olivier Pieters <olivier.pieters@ugent.be>
16 | Pavan Ramkumar <pavan.ramkumar@gmail.com> pavanramkumar <pavan.ramkumar@gmail.com>
17 | Pavan Ramkumar <pavan.ramkumar@gmail.com> Pavan Ramkumar <pavan.ramkumar@northwestern.edu>
18 | Pavan Ramkumar <pavan.ramkumar@gmail.com> pavanramkumar <pavan.ramkumar@northwestern.edu>
19 | Peter Foley <pwfoley@gmail.com> Peter Foley (605) <peter@605.tv>
20 | Ravi Prakash Garg <ravigarg27@gmail.com> Ravi Prakash Garg <rpg553@gmail.com>
21 | Ravi Prakash Garg <ravigarg27@gmail.com> Ravi Prakash Garg <rpg553@fsm.northwestern.edu>
22 | Scott Otterson <scotto@sharpleaf.org>
23 | Talles Alves <toliveiradesouzaalv@luc.edu>
24 | Titipat Achakulvisut <my.titipat@gmail.com>
25 | Tommy Odland <tommy.odland@gmail.com> tommyod <tommy.odland@gmail.com>
26 | Tommy Odland <tommy.odland@gmail.com> Tommy <10076072+tommyod@users.noreply.github.com>
27 | Yu Umegaki <yu.umegaki@gmail.com>
28 | Vinicius de F. Marques <vini.type@gmail.com>
29 | Yu Umegaki <umegaki@msi.co.jp>
30 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: python
 2 | env:
 3 |     - PYTHON=3.5
 4 |     - PYTHON=3.6
 5 |     - PYTHON=3.7
 6 | 
 7 | before_install:
 8 |   - wget -q http://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh -O miniconda.sh
 9 |   - chmod +x miniconda.sh
10 |   - ./miniconda.sh -b -p /home/travis/miniconda
11 |   - export PATH=/home/travis/miniconda/bin:$PATH
12 |   - conda update --yes conda
13 | 
14 | install:
15 |     - conda create -n testenv --yes pip python=$PYTHON
16 |     - source activate testenv
17 |     - conda install --yes --file requirements.txt
18 |     - pip install --upgrade twine
19 |     - pip install matplotlib==3.0
20 |     - python setup.py develop
21 |     - python setup.py sdist bdist_wheel
22 | 
23 | script:
24 |     - # Checks whether your distribution’s long description will render correctly on PyPI.
25 |     - twine check dist/*
26 |     - # Run tests, show verbose output and print the top 10 slowest running tests
27 |     - py.test --cov=pyglmnet tests/ --verbose --durations=10
28 |     - # Run doctests
29 |     - py.test pyglmnet/pyglmnet.py --verbose --doctest-modules 
30 |     - # Run flake8 to check that package and tests adhere to PEP8
31 |     - make flake
32 | 
33 | after_success:
34 |     - bash <(curl -s https://codecov.io/bash)
35 | 


--------------------------------------------------------------------------------
/.zenodo.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "title": "Pyglmnet: Python implementation of elastic-net regularized generalized linear models",
  3 |   "description": "Pyglmnet is a Python library that provides an implementation of generalized linear models with advanced regularization methods, and a scikit-learn compatible API.",
  4 |   "creators": [
  5 |     {
  6 |       "affiliation": "Martinos Center of Biomedical Imaging",
  7 |       "name": "Mainak Jas",
  8 |       "orcid": "0000-0002-3199-9027"
  9 |     },
 10 |     {
 11 |       "affiliation": "University of Pennsylvania",
 12 |       "name": "Titipat Achakulvisut",
 13 |       "orcid": "0000-0002-2124-2979"
 14 |     },
 15 |     {
 16 |       "affiliation": "Loyola University",
 17 |       "name": "Aid Idrizović"
 18 |     },
 19 |     {
 20 |       "affiliation": "Syracuse University",
 21 |       "name": "Daniel E. Acuna"
 22 |     },
 23 |     {
 24 |       "affiliation": "Northwestern University",
 25 |       "name": "Matthew Antalek"
 26 |     },
 27 |     {
 28 |       "affiliation": "Loyola University",
 29 |       "name": "Vinicius Marques"
 30 |     },
 31 |     {
 32 |       "affiliation": "Sonat Consulting",
 33 |       "name": "Tommy Odland"
 34 |     },
 35 |     {
 36 |       "affiliation": "Northwestern University",
 37 |       "name": "Ravi Prakash Garg"
 38 |     },
 39 |     {
 40 |       "affiliation": "Princeton University",
 41 |       "name": "Mayank Agrawal"
 42 |     },
 43 |     {
 44 |       "affiliation": "NTT Data Mathematical Systems Inc",
 45 |       "name": "Yu Umegaki"
 46 |     },
 47 |     {
 48 |       "affiliation": "605",
 49 |       "name": "Peter Foley",
 50 |       "orcid": "0000-0002-0304-7213"
 51 |     },
 52 |     {
 53 |       "affiliation": "Rockets of Awesome",
 54 |       "name": "Hugo L Fernandes",
 55 |       "orcid": "0000-0002-0168-4104"
 56 |     },
 57 |     {
 58 |       "affiliation": "Epoch Capital",
 59 |       "name": "Drew Harris"
 60 |     },
 61 |     {
 62 |       "affiliation": "University of Washington",
 63 |       "name": "Beibin Li"
 64 |     },
 65 |     {
 66 |       "affiliation": "Ghent University, Research Institute for Agriculture Fisheries and Food",
 67 |       "name": "Olivier Pieters",
 68 |       "orcid": "0000-0002-5473-4849"
 69 |     },
 70 |     {
 71 |       "affiliation": "Clean Power Research",
 72 |       "name": "Scott Otterson"
 73 |     },
 74 |     {
 75 |       "affiliation": "University of Trento",
 76 |       "name": "Giovanni De Toni",
 77 |       "orcid": "0000-0002-8387-9983"
 78 |     },
 79 |     {
 80 |       "affiliation": "Columbia University",
 81 |       "name": "Chris Rodgers",
 82 |       "orcid": "0000-0003-1762-3450"
 83 |     },
 84 |     {
 85 |       "affiliation": "Georgia Institute of Technology",
 86 |       "name": "Eva Dyer"
 87 |     },
 88 |     {
 89 |       "affiliation": "Martinos Center of Biomedical Imaging",
 90 |       "name": "Matti Hamalainen"
 91 |     },
 92 |     {
 93 |       "affiliation": "University of Pennsylvania",
 94 |       "name": "Konrad Kording"
 95 |     },
 96 |     {
 97 |       "affiliation": "System1 Biosciences Inc",
 98 |       "name": "Pavan Ramkumar",
 99 |       "orcid": "0000-0001-7450-0727"
100 |     }
101 |   ],
102 |   "keywords": [
103 |     "Python",
104 |     "glm",
105 |     "machine-learning",
106 |     "lasso",
107 |     "elastic-net",
108 |     "group-lasso"
109 |   ],
110 |   "license": "MIT",
111 |   "upload_type": "software"
112 | }
113 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Pavan Ramkumar
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
 1 | include *.png
 2 | include *.rst
 3 | include requirements.txt
 4 | include LICENSE
 5 | include pyglmnet/__init__.py
 6 | include examples/community_crime.csv
 7 | 
 8 | recursive-include examples *.py
 9 | recursive-include examples *.txt
10 | 
11 | recursive-include pyglmnet *.py
12 | 
13 | ### Exclude
14 | 
15 | exclude .github
16 | exclude Makefile
17 | exclude CONTRIBUTING.md
18 | exclude distribution_instructions.md
19 | exclude .coveragerc
20 | exclude *.yml
21 | exclude .mailmap
22 | exclude PLANS.md
23 | recursive-exclude pyglmnet *.pyc
24 | 
25 | recursive-exclude doc *
26 | recursive-exclude tests *.py
27 | recursive-exclude paper *
28 | exclude tests
29 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # simple makefile to simplify repetetive build env management tasks under posix
 2 | 
 3 | PYTHON ?= python
 4 | PYTESTS ?= pytest
 5 | 
 6 | all: clean inplace test
 7 | 
 8 | clean-pyc:
 9 | 	find . -name "*.pyc" | xargs rm -f
10 | 
11 | clean-so:
12 | 	find . -name "*.so" | xargs rm -f
13 | 	find . -name "*.pyd" | xargs rm -f
14 | 
15 | clean-build:
16 | 	rm -rf _build
17 | 
18 | clean-ctags:
19 | 	rm -f tags
20 | 
21 | clean-cache:
22 | 	find . -name "__pycache__" | xargs rm -rf
23 | 
24 | clean: clean-build clean-pyc clean-so clean-ctags clean-cache
25 | 
26 | inplace:
27 | 	$(PYTHON) setup.py install
28 | 
29 | test: inplace check-manifest
30 | 	rm -f .coverage
31 | 	$(PYTESTS) pyglmnet
32 | 
33 | test-doc:
34 | 	$(PYTESTS) --doctest-modules --doctest-ignore-import-errors
35 | 
36 | test-coverage:
37 | 	rm -rf coverage .coverage
38 | 	$(PYTESTS) --cov=pyglmnet --cov-report html:coverage
39 | 
40 | trailing-spaces:
41 | 	find . -name "*.py" | xargs perl -pi -e 's/[ \t]*$$//'
42 | 
43 | upload-pipy:
44 | 	python setup.py sdist bdist_egg register upload
45 | 
46 | check-manifest:
47 | 	check-manifest --ignore .circleci*,doc,.DS_Store,paper
48 | 
49 | flake:
50 | 	@if command -v flake8 > /dev/null; then \
51 | 		echo "Running flake8"; \
52 | 		flake8 --count pyglmnet examples; \
53 | 	else \
54 | 		echo "flake8 not found, please install it!"; \
55 | 		exit 1; \
56 | 	fi;
57 | 	@echo "flake8 passed"
58 | 
59 | pydocstyle:
60 | 	@echo "Running pydocstyle"
61 | 	@pydocstyle
62 | 
63 | pep:
64 | 	@$(MAKE) -k flake pydocstyle
65 | 
66 | build-doc:
67 | 	cd doc; make clean
68 | 	cd doc; make html
69 | 


--------------------------------------------------------------------------------
/PLANS.md:
--------------------------------------------------------------------------------
 1 | # Future directions
 2 | 
 3 | This is a collection of ideas for future directions of this project, mainly intended to keep track of suggestions.
 4 | The ideas may ideally be executed through funding channels such as [GSOC](https://developers.google.com/open-source/gsoc/)
 5 | 
 6 | ### Enhancements and Differentiators
 7 | - Provide alternate penalty functions e.g. Tikhonov regularizers for the L2 part of the loss function: very useful for time series models
 8 | - Implement group lasso/ group elastic net: very useful to regularize in groups
 9 | - Implement SGD variants by potentially integrating with `sklearn`: useful for big data
10 | - Make a contribution to Spark's MLLib: useful for streaming data
11 | 
12 | ### Use cases
13 | - Interface with companion packages such as proposed `Spykes` and `NeuroSTRF` to demonstrate use cases for neural data
14 | - Interface with big functional neural data as Jeremy Freeman's mouse or zerbrafish datasets.
15 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
  1 | pyglmnet
  2 | ========
  3 | 
  4 | A python implementation of elastic-net regularized generalized linear models
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | |License| |Travis| |Codecov| |Circle| |Gitter| |DOI| |JOSS|
  8 | 
  9 | `[Documentation (stable version)]`_ `[Documentation (development version)]`_
 10 | 
 11 | .. image:: https://user-images.githubusercontent.com/15852194/67919367-70482600-fb76-11e9-9b86-891969bd2bee.jpg
 12 | 
 13 | -  Pyglmnet provides a wide range of noise models (and paired canonical
 14 |    link functions): ``'gaussian'``, ``'binomial'``, ``'probit'``,
 15 |    ``'gamma'``, '``poisson``', and ``'softplus'``.
 16 | 
 17 | -  It supports a wide range of regularizers: ridge, lasso, elastic net,
 18 |    `group
 19 |    lasso <https://en.wikipedia.org/wiki/Proximal_gradient_methods_for_learning#Group_lasso>`__,
 20 |    and `Tikhonov
 21 |    regularization <https://en.wikipedia.org/wiki/Tikhonov_regularization>`__.
 22 | 
 23 | -  We have implemented a cyclical coordinate descent optimizer with
 24 |    Newton update, active sets, update caching, and warm restarts. This
 25 |    optimization approach is identical to the one used in R package.
 26 | 
 27 | -  A number of Python wrappers exist for the R glmnet package (e.g.
 28 |    `here <https://github.com/civisanalytics/python-glmnet>`__ and
 29 |    `here <https://github.com/dwf/glmnet-python>`__) but in contrast to
 30 |    these, Pyglmnet is a pure python implementation. Therefore, it is
 31 |    easy to modify and introduce additional noise models and regularizers
 32 |    in the future.
 33 | 
 34 | Installation
 35 | ~~~~~~~~~~~~
 36 | 
 37 | Install the stable PyPI version with ``pip``
 38 | 
 39 | .. code:: bash
 40 | 
 41 |     $ pip install pyglmnet
 42 | 
 43 | For the bleeding edge development version:
 44 | 
 45 | Clone the repository.
 46 | 
 47 | .. code:: bash
 48 | 
 49 |     $ pip install https://api.github.com/repos/glm-tools/pyglmnet/zipball/master
 50 | 
 51 | Getting Started
 52 | ~~~~~~~~~~~~~~~
 53 | 
 54 | 
 55 | Here is an example on how to use the ``GLM`` estimator.
 56 | 
 57 | .. code:: python
 58 | 
 59 |     import numpy as np
 60 |     import scipy.sparse as sps
 61 | 
 62 |     import matplotlib.pyplot as plt
 63 |     from pyglmnet import GLM, simulate_glm
 64 | 
 65 |     n_samples, n_features = 1000, 100
 66 |     distr = 'poisson'
 67 | 
 68 |     # sample a sparse model
 69 |     np.random.seed(42)
 70 |     beta0 = np.random.rand()
 71 |     beta = sps.random(1, n_features, density=0.2).toarray()[0]
 72 | 
 73 |     # simulate data
 74 |     Xtrain = np.random.normal(0.0, 1.0, [n_samples, n_features])
 75 |     ytrain = simulate_glm('poisson', beta0, beta, Xtrain)
 76 |     Xtest = np.random.normal(0.0, 1.0, [n_samples, n_features])
 77 |     ytest = simulate_glm('poisson', beta0, beta, Xtest)
 78 | 
 79 |     # create an instance of the GLM class
 80 |     glm = GLM(distr='poisson', score_metric='pseudo_R2', reg_lambda=0.01)
 81 | 
 82 |     # fit the model on the training data
 83 |     glm.fit(Xtrain, ytrain)
 84 | 
 85 |     # predict using fitted model on the test data
 86 |     yhat = glm.predict(Xtest)
 87 | 
 88 |     # score the model on test data
 89 |     pseudo_R2 = glm.score(Xtest, ytest)
 90 |     print('Pseudo R^2 is %.3f' % pseudo_R2)
 91 | 
 92 |     # plot the true coefficients and the estimated ones
 93 |     plt.stem(beta, markerfmt='r.', label='True coefficients')
 94 |     plt.stem(glm.beta_, markerfmt='b.', label='Estimated coefficients')
 95 |     plt.ylabel(r'$\beta$')
 96 |     plt.legend(loc='upper right')
 97 | 
 98 |     # plot the true vs predicted label
 99 |     plt.figure()
100 |     plt.plot(ytest, yhat, '.')
101 |     plt.xlabel('True labels')
102 |     plt.ylabel('Predicted labels')
103 |     plt.plot([0, ytest.max()], [0, ytest.max()], 'r--')
104 |     plt.show()
105 | 
106 | `More pyglmnet examples and use
107 | cases <http://glm-tools.github.io/pyglmnet/auto_examples/index.html>`__.
108 | 
109 | Tutorial
110 | ~~~~~~~~
111 | 
112 | Here is an `extensive
113 | tutorial <http://glm-tools.github.io/pyglmnet/tutorial.html>`__ on GLMs,
114 | optimization and pseudo-code.
115 | 
116 | Here are
117 | `slides <https://pavanramkumar.github.io/pydata-chicago-2016>`__ from a
118 | talk at `PyData Chicago
119 | 2016 <http://pydata.org/chicago2016/schedule/presentation/15/>`__,
120 | corresponding `tutorial
121 | notebooks <http://github.com/pavanramkumar/pydata-chicago-2016>`__ and a
122 | `video <https://www.youtube.com/watch?v=zXec96KD1uA>`__.
123 | 
124 | How to contribute?
125 | ~~~~~~~~~~~~~~~~~~
126 | 
127 | We welcome pull requests. Please see our `developer documentation
128 | page <https://glm-tools.github.io/pyglmnet/contributing.html>`__ for more
129 | details.
130 | 
131 | Citation
132 | ~~~~~~~~
133 | 
134 | If you use ``pyglmnet`` package in your publication, please cite us from
135 | our `JOSS publication <https://doi.org/10.21105/joss.01959>`__ using the following BibTex
136 | 
137 | .. code::
138 | 
139 |    @article{Jas2020,
140 |    doi = {10.21105/joss.01959},
141 |    url = {https://doi.org/10.21105/joss.01959},
142 |    year = {2020},
143 |    publisher = {The Open Journal},
144 |    volume = {5},
145 |    number = {47},
146 |    pages = {1959},
147 |    author = {Mainak Jas and Titipat Achakulvisut and Aid Idrizović
148 |              and Daniel Acuna and Matthew Antalek and Vinicius Marques
149 |              and Tommy Odland and Ravi Garg and Mayank Agrawal
150 |              and Yu Umegaki and Peter Foley and Hugo Fernandes
151 |              and Drew Harris and Beibin Li and Olivier Pieters
152 |              and Scott Otterson and Giovanni De Toni and Chris Rodgers
153 |              and Eva Dyer and Matti Hamalainen and Konrad Kording and Pavan Ramkumar},
154 |    title = {{P}yglmnet: {P}ython implementation of elastic-net regularized generalized linear models},
155 |    journal = {Journal of Open Source Software}
156 |    }
157 | 
158 | Acknowledgments
159 | ~~~~~~~~~~~~~~~
160 | 
161 | -  `Konrad Kording <http://kordinglab.com>`__ for funding and support
162 | -  `Sara
163 |    Solla <http://www.physics.northwestern.edu/people/joint-faculty/sara-solla.html>`__
164 |    for masterful GLM lectures
165 | 
166 | License
167 | ~~~~~~~
168 | 
169 | MIT License Copyright (c) 2016-2019 Pavan Ramkumar
170 | 
171 | .. |License| image:: https://img.shields.io/badge/license-MIT-blue.svg?style=flat
172 |    :target: https://github.com/glm-tools/pyglmnet/blob/master/LICENSE
173 | .. |Travis| image:: https://api.travis-ci.org/glm-tools/pyglmnet.svg?branch=master
174 |    :target: https://travis-ci.org/glm-tools/pyglmnet
175 | .. |Codecov| image:: https://codecov.io/github/glm-tools/pyglmnet/coverage.svg?precision=0
176 |    :target: https://codecov.io/gh/glm-tools/pyglmnet
177 | .. |Circle| image:: https://circleci.com/gh/glm-tools/pyglmnet.svg?style=svg
178 |    :target: https://circleci.com/gh/glm-tools/pyglmnet
179 | .. |Gitter| image:: https://badges.gitter.im/glm-tools/pyglmnet.svg
180 |    :target: https://gitter.im/pavanramkumar/pyglmnet?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge
181 | .. |DOI| image:: https://zenodo.org/badge/55302570.svg
182 |    :target: https://zenodo.org/badge/latestdoi/55302570
183 | .. |JOSS| image:: https://joss.theoj.org/papers/10.21105/joss.01959/status.svg
184 |    :target: https://doi.org/10.21105/joss.01959
185 | .. _[Documentation (stable version)]: http://glm-tools.github.io/pyglmnet
186 | 


--------------------------------------------------------------------------------
/doc/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for Sphinx documentation
  2 | #
  3 | 
  4 | # You can set these variables from the command line.
  5 | SPHINXOPTS    = -v
  6 | SPHINXBUILD   = sphinx-build
  7 | PAPER         =
  8 | BUILDDIR      = _build
  9 | 
 10 | # User-friendly check for sphinx-build
 11 | ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
 12 | $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
 13 | endif
 14 | 
 15 | # Internal variables.
 16 | PAPEROPT_a4     = -D latex_paper_size=a4
 17 | PAPEROPT_letter = -D latex_paper_size=letter
 18 | ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 19 | # the i18n builder cannot share the environment and doctrees with the others
 20 | I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 21 | 
 22 | .PHONY: help
 23 | help:
 24 | 	@echo "Please use \`make <target>' where <target> is one of"
 25 | 	@echo "  html-noplot to make standalone HTML files, without plotting anything"
 26 | 	@echo "  html       to make standalone HTML files"
 27 | 	@echo "  dirhtml    to make HTML files named index.html in directories"
 28 | 	@echo "  singlehtml to make a single large HTML file"
 29 | 	@echo "  pickle     to make pickle files"
 30 | 	@echo "  htmlhelp   to make HTML files and a HTML help project"
 31 | 	@echo "  qthelp     to make HTML files and a qthelp project"
 32 | 	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 33 | 	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 34 | 	@echo "  changes    to make an overview of all changed/added/deprecated items"
 35 | 	@echo "  linkcheck  to check all external links for integrity"
 36 | 	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
 37 | 	@echo "  coverage   to run coverage check of the documentation (if enabled)"
 38 | 	@echo "  install    to make the html and push it online"
 39 | 
 40 | .PHONY: clean
 41 | 
 42 | clean:
 43 | 	rm -rf $(BUILDDIR)/
 44 | 	rm -rf auto_examples/
 45 | 	rm -rf generated/
 46 | 	rm -rf modules/
 47 | 	rm -rf tutorials/
 48 | 
 49 | html-noplot:
 50 | 	$(SPHINXBUILD) -D plot_gallery=0 -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 51 | 	@echo
 52 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 53 | 
 54 | .PHONY: html
 55 | html:
 56 | 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 57 | 	@echo
 58 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 59 | 
 60 | .PHONY: dirhtml
 61 | dirhtml:
 62 | 	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
 63 | 	@echo
 64 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
 65 | 
 66 | .PHONY: singlehtml
 67 | singlehtml:
 68 | 	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
 69 | 	@echo
 70 | 	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
 71 | 
 72 | .PHONY: pickle
 73 | pickle:
 74 | 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
 75 | 	@echo
 76 | 	@echo "Build finished; now you can process the pickle files."
 77 | 
 78 | .PHONY: htmlhelp
 79 | htmlhelp:
 80 | 	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
 81 | 	@echo
 82 | 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 83 | 		  ".hhp project file in $(BUILDDIR)/htmlhelp."
 84 | 
 85 | .PHONY: qthelp
 86 | qthelp:
 87 | 	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
 88 | 	@echo
 89 | 	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
 90 | 		  ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
 91 | 	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/pyglmnet.qhcp"
 92 | 	@echo "To view the help file:"
 93 | 	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/pyglmnet.qhc"
 94 | 
 95 | .PHONY: latex
 96 | latex:
 97 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
 98 | 	@echo
 99 | 	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
100 | 	@echo "Run \`make' in that directory to run these through (pdf)latex" \
101 | 		  "(use \`make latexpdf' here to do that automatically)."
102 | 
103 | .PHONY: latexpdf
104 | latexpdf:
105 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
106 | 	@echo "Running LaTeX files through pdflatex..."
107 | 	$(MAKE) -C $(BUILDDIR)/latex all-pdf
108 | 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
109 | 
110 | .PHONY: changes
111 | changes:
112 | 	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
113 | 	@echo
114 | 	@echo "The overview file is in $(BUILDDIR)/changes."
115 | 
116 | .PHONY: linkcheck
117 | linkcheck:
118 | 	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
119 | 	@echo
120 | 	@echo "Link check complete; look for any errors in the above output " \
121 | 		  "or in $(BUILDDIR)/linkcheck/output.txt."
122 | 
123 | .PHONY: doctest
124 | doctest:
125 | 	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
126 | 	@echo "Testing of doctests in the sources finished, look at the " \
127 | 		  "results in $(BUILDDIR)/doctest/output.txt."
128 | 
129 | .PHONY: coverage
130 | coverage:
131 | 	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
132 | 	@echo "Testing of coverage in the sources finished, look at the " \
133 | 		  "results in $(BUILDDIR)/coverage/python.txt."
134 | 
135 | install:
136 | 	rm -rf _build/doctrees _build/pyglmnet.github.io
137 | 	# first clone the glm-tools/pyglmnet repo because it may ask
138 | 	# for password and we don't want to delay this long build in
139 | 	# the middle of it
140 | 	# --no-checkout just fetches the root folder without content
141 | 	# --depth 1 is a speed optimization since we don't need the
142 | 	# history prior to the last commit
143 | 	# -b gh-pages fetches only the branch for the gh-pages
144 | 	git clone -b gh-pages --single-branch --no-checkout --depth 1 git@github.com:glm-tools/pyglmnet.git _build/pyglmnet.github.io
145 | 	touch _build/pyglmnet.github.io/.nojekyll
146 | 	make html
147 | 	cd _build/ && \
148 | 	cp -r html/* pyglmnet.github.io && \
149 | 	cd pyglmnet.github.io && \
150 | 	git add * && \
151 | 	git add .nojekyll && \
152 | 	git commit -a -m 'Make install' && \
153 | 	git push
154 | 


--------------------------------------------------------------------------------
/doc/README.md:
--------------------------------------------------------------------------------
 1 | # pyglmnet documentation
 2 | 
 3 | Please see the full documentation page [here](http://glm-tools.github.io/pyglmnet/).
 4 | 
 5 | We use [`sphinx`](https://www.sphinx-doc.org/en/master/) with [`sphinx-rtd-theme`](https://sphinx-rtd-theme.readthedocs.io/en/stable/) to generate a documentation page.
 6 | 
 7 | To build the documentation page, run `make html`. All static files will be built in
 8 | `_build/html/` where you can open them using the web browser.
 9 | 
10 | To push the built documentation page to the `gh-pages` branch, simply run `make install`
11 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/__init__.py:
--------------------------------------------------------------------------------
 1 | """Sphinx ReadTheDocs theme.
 2 | 
 3 | From https://github.com/ryan-roemer/sphinx-bootstrap-theme.
 4 | 
 5 | """
 6 | import os
 7 | 
 8 | VERSION = (0, 1, 9)
 9 | 
10 | __version__ = ".".join(str(v) for v in VERSION)
11 | __version_full__ = __version__
12 | 
13 | 
14 | def get_html_theme_path():
15 |     """Return list of HTML theme paths."""
16 |     cur_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
17 |     return cur_dir
18 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/breadcrumbs.html:
--------------------------------------------------------------------------------
 1 | {# Support for Sphinx 1.3+ page_source_suffix, but don't break old builds. #}
 2 | 
 3 | {% if page_source_suffix %} 
 4 | {% set suffix = page_source_suffix %}
 5 | {% else %}
 6 | {% set suffix = source_suffix %}
 7 | {% endif %}
 8 | 
 9 | <div role="navigation" aria-label="breadcrumbs navigation">
10 |   <ul class="wy-breadcrumbs">
11 |     <li><a href="{{ pathto(master_doc) }}">Docs</a> &raquo;</li>
12 |       {% for doc in parents %}
13 |         <li><a href="{{ doc.link|e }}">{{ doc.title }}</a> &raquo;</li>
14 |       {% endfor %}
15 |     <li>{{ title }}</li>
16 |     <li class="wy-breadcrumbs-aside">
17 |       {% if pagename != "search" %}
18 |         {% if display_github %}
19 |           <a href="https://{{ github_host|default("github.com") }}/{{ github_user }}/{{ github_repo }}/blob/{{ github_version }}{{ conf_py_path }}{{ pagename }}{{ suffix }}" class="fa fa-github"> Edit on GitHub</a>
20 |         {% elif display_bitbucket %}
21 |           <a href="https://bitbucket.org/{{ bitbucket_user }}/{{ bitbucket_repo }}/src/{{ bitbucket_version}}{{ conf_py_path }}{{ pagename }}{{ suffix }}" class="fa fa-bitbucket"> Edit on Bitbucket</a>
22 |         {% elif show_source and source_url_prefix %}
23 |           <a href="{{ source_url_prefix }}{{ pagename }}{{ suffix }}">View page source</a>
24 |         {% elif show_source and has_source and sourcename %}
25 |           <a href="{{ pathto('_sources/' + sourcename, true)|e }}" rel="nofollow"> View page source</a>
26 |         {% endif %}
27 |       {% endif %}
28 |     </li>
29 |   </ul>
30 |   <hr/>
31 | </div>
32 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/footer.html:
--------------------------------------------------------------------------------
 1 | <footer>
 2 |   {% if next or prev %}
 3 |     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
 4 |       {% if next %}
 5 |         <a href="{{ next.link|e }}" class="btn btn-neutral float-right" title="{{ next.title|striptags|e }}" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
 6 |       {% endif %}
 7 |       {% if prev %}
 8 |         <a href="{{ prev.link|e }}" class="btn btn-neutral" title="{{ prev.title|striptags|e }}" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>
 9 |       {% endif %}
10 |     </div>
11 |   {% endif %}
12 | 
13 |   <hr/>
14 | 
15 |   <div role="contentinfo">
16 |     <p>
17 |     {%- if show_copyright %}
18 |       {%- if hasdoc('copyright') %}
19 |         {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; <a href="{{ path }}">Copyright</a> {{ copyright }}.{% endtrans %}
20 |       {%- else %}
21 |         {% trans copyright=copyright|e %}&copy; Copyright {{ copyright }}.{% endtrans %}
22 |       {%- endif %}
23 |     {%- endif %}
24 | 
25 |     {%- if build_id and build_url %}
26 |       {% trans build_url=build_url, build_id=build_id %}
27 |         <span class="build">
28 |           Build
29 |           <a href="{{ build_url }}">{{ build_id }}</a>.
30 |         </span>
31 |       {% endtrans %}
32 |     {%- elif commit %}
33 |       {% trans commit=commit %}
34 |         <span class="commit">
35 |           Revision <code>{{ commit }}</code>.
36 |         </span>
37 |       {% endtrans %}
38 |     {%- elif last_updated %}
39 |       {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
40 |     {%- endif %}
41 | 
42 |     </p>
43 |   </div>
44 | 
45 |   {%- if show_sphinx %}
46 |   {% trans %}Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>{% endtrans %}.
47 |   {%- endif %}
48 | 
49 |   {%- block extrafooter %} {% endblock %}
50 | 
51 | </footer>
52 | 
53 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/layout.html:
--------------------------------------------------------------------------------
  1 | {# TEMPLATE VAR SETTINGS #}
  2 | {%- set url_root = pathto('', 1) %}
  3 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
  4 | {%- if not embedded and docstitle %}
  5 |   {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
  6 | {%- else %}
  7 |   {%- set titlesuffix = "" %}
  8 | {%- endif %}
  9 | 
 10 | <!DOCTYPE html>
 11 | <!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
 12 | <!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
 13 | <head>
 14 |   <meta charset="utf-8">
 15 |   {{ metatags }}
 16 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 17 |   {% block htmltitle %}
 18 |   <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
 19 |   {% endblock %}
 20 | 
 21 |   {# FAVICON #}
 22 |   {% if favicon %}
 23 |     <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
 24 |   {% endif %}
 25 | 
 26 |   {# CSS #}
 27 | 
 28 |   {# OPENSEARCH #}
 29 |   {% if not embedded %}
 30 |     {% if use_opensearch %}
 31 |       <link rel="search" type="application/opensearchdescription+xml" title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}" href="{{ pathto('_static/opensearch.xml', 1) }}"/>
 32 |     {% endif %}
 33 | 
 34 |   {% endif %}
 35 | 
 36 |   {# RTD hosts this file, so just load on non RTD builds #}
 37 |   {% if not READTHEDOCS %}
 38 |     <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
 39 |   {% endif %}
 40 | 
 41 |   {% for cssfile in css_files %}
 42 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
 43 |   {% endfor %}
 44 | 
 45 |   {% for cssfile in extra_css_files %}
 46 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
 47 |   {% endfor %}
 48 | 
 49 |   {%- block linktags %}
 50 |     {%- if hasdoc('about') %}
 51 |         <link rel="author" title="{{ _('About these documents') }}"
 52 |               href="{{ pathto('about') }}"/>
 53 |     {%- endif %}
 54 |     {%- if hasdoc('genindex') %}
 55 |         <link rel="index" title="{{ _('Index') }}"
 56 |               href="{{ pathto('genindex') }}"/>
 57 |     {%- endif %}
 58 |     {%- if hasdoc('search') %}
 59 |         <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}"/>
 60 |     {%- endif %}
 61 |     {%- if hasdoc('copyright') %}
 62 |         <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}"/>
 63 |     {%- endif %}
 64 |     <link rel="top" title="{{ docstitle|e }}" href="{{ pathto('index') }}"/>
 65 |     {%- if parents %}
 66 |         <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}"/>
 67 |     {%- endif %}
 68 |     {%- if next %}
 69 |         <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}"/>
 70 |     {%- endif %}
 71 |     {%- if prev %}
 72 |         <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}"/>
 73 |     {%- endif %}
 74 |   {%- endblock %}
 75 |   {%- block extrahead %} {% endblock %}
 76 | 
 77 |   {# Keep modernizr in head - http://modernizr.com/docs/#installing #}
 78 |   <script src="{{ pathto('_static/js/modernizr.min.js', 1) }}"></script>
 79 | 
 80 | </head>
 81 | 
 82 | <body class="wy-body-for-nav" role="document">
 83 | 
 84 |   {% block extrabody %} {% endblock %}
 85 |   <div class="wy-grid-for-nav">
 86 | 
 87 |     {# SIDE NAV, TOGGLES ON MOBILE #}
 88 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 89 |       <div class="wy-side-scroll">
 90 |         <div class="wy-side-nav-search">
 91 |           {% block sidebartitle %}
 92 | 
 93 |           {% if logo and theme_logo_only %}
 94 |             <a href="{{ pathto(master_doc) }}">
 95 |           {% else %}
 96 |             <a href="{{ pathto(master_doc) }}" class="icon icon-home"> {{ project }}
 97 |           {% endif %}
 98 | 
 99 |           {% if logo %}
100 |             {# Not strictly valid HTML, but it's the only way to display/scale it properly, without weird scripting or heaps of work #}
101 |             <img src="{{ pathto('_static/' + logo, 1) }}" class="logo" />
102 |           {% endif %}
103 |           </a>
104 | 
105 |           {% if theme_display_version %}
106 |             {%- set nav_version = version %}
107 |             {% if READTHEDOCS and current_version %}
108 |               {%- set nav_version = current_version %}
109 |             {% endif %}
110 |             {% if nav_version %}
111 |               <div class="version">
112 |                 {{ nav_version }}
113 |               </div>
114 |             {% endif %}
115 |           {% endif %}
116 | 
117 |           {% include "searchbox.html" %}
118 | 
119 |           {% endblock %}
120 |         </div>
121 | 
122 |         <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
123 |           {% block menu %}
124 |             {% set toctree = toctree(maxdepth=4, collapse=theme_collapse_navigation, includehidden=True) %}
125 |             {% if toctree %}
126 |                 {{ toctree }}
127 |             {% else %}
128 |                 <!-- Local TOC -->
129 |                 <div class="local-toc">{{ toc }}</div>
130 |             {% endif %}
131 |           {% endblock %}
132 |         </div>
133 |       </div>
134 |     </nav>
135 | 
136 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
137 | 
138 |       {# MOBILE NAV, TRIGGLES SIDE NAV ON TOGGLE #}
139 |       <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
140 |         <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
141 |         <a href="{{ pathto(master_doc) }}">{{ project }}</a>
142 |       </nav>
143 | 
144 | 
145 |       {# PAGE CONTENT #}
146 |       <div class="wy-nav-content">
147 |         <div class="rst-content">
148 |           {% include "breadcrumbs.html" %}
149 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
150 |            <div itemprop="articleBody">
151 |             {% block body %}{% endblock %}
152 |            </div>
153 |           </div>
154 |           {% include "footer.html" %}
155 |         </div>
156 |       </div>
157 | 
158 |     </section>
159 | 
160 |   </div>
161 |   {% include "versions.html" %}
162 | 
163 |   {% if not embedded %}
164 | 
165 |     <script type="text/javascript">
166 |         var DOCUMENTATION_OPTIONS = {
167 |             URL_ROOT:'{{ url_root }}',
168 |             VERSION:'{{ release|e }}',
169 |             COLLAPSE_INDEX:false,
170 |             FILE_SUFFIX:'{{ '' if no_search_suffix else file_suffix }}',
171 |             HAS_SOURCE:  {{ has_source|lower }}
172 |         };
173 |     </script>
174 |     {%- for scriptfile in script_files %}
175 |       <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
176 |     {%- endfor %}
177 | 
178 |   {% endif %}
179 | 
180 |   {# RTD hosts this file, so just load on non RTD builds #}
181 |   {% if not READTHEDOCS %}
182 |     <script type="text/javascript" src="{{ pathto('_static/js/theme.js', 1) }}"></script>
183 |   {% endif %}
184 | 
185 |   {# STICKY NAVIGATION #}
186 |   {% if theme_sticky_navigation %}
187 |   <script type="text/javascript">
188 |       jQuery(function () {
189 |           SphinxRtdTheme.StickyNav.enable();
190 |       });
191 |   </script>
192 |   {% endif %}
193 | 
194 |   {%- block footer %} {% endblock %}
195 | 
196 | </body>
197 | </html>
198 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/layout_old.html:
--------------------------------------------------------------------------------
  1 | {#
  2 |     basic/layout.html
  3 |     ~~~~~~~~~~~~~~~~~
  4 | 
  5 |     Master layout template for Sphinx themes.
  6 | 
  7 |     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
  8 |     :license: BSD, see LICENSE for details.
  9 | #}
 10 | {%- block doctype -%}
 11 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 12 |   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 13 | {%- endblock %}
 14 | {%- set reldelim1 = reldelim1 is not defined and ' &raquo;' or reldelim1 %}
 15 | {%- set reldelim2 = reldelim2 is not defined and ' |' or reldelim2 %}
 16 | {%- set render_sidebar = (not embedded) and (not theme_nosidebar|tobool) and
 17 |                          (sidebars != []) %}
 18 | {%- set url_root = pathto('', 1) %}
 19 | {# XXX necessary? #}
 20 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
 21 | {%- if not embedded and docstitle %}
 22 |   {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
 23 | {%- else %}
 24 |   {%- set titlesuffix = "" %}
 25 | {%- endif %}
 26 | 
 27 | {%- macro relbar() %}
 28 |     <div class="related">
 29 |       <h3>{{ _('Navigation') }}</h3>
 30 |       <ul>
 31 |         {%- for rellink in rellinks %}
 32 |         <li class="right" {% if loop.first %}style="margin-right: 10px"{% endif %}>
 33 |           <a href="{{ pathto(rellink[0]) }}" title="{{ rellink[1]|striptags|e }}"
 34 |              {{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>
 35 |           {%- if not loop.first %}{{ reldelim2 }}{% endif %}</li>
 36 |         {%- endfor %}
 37 |         {%- block rootrellink %}
 38 |         <li><a href="{{ pathto(master_doc) }}">{{ shorttitle|e }}</a>{{ reldelim1 }}</li>
 39 |         {%- endblock %}
 40 |         {%- for parent in parents %}
 41 |           <li><a href="{{ parent.link|e }}" {% if loop.last %}{{ accesskey("U") }}{% endif %}>{{ parent.title }}</a>{{ reldelim1 }}</li>
 42 |         {%- endfor %}
 43 |         {%- block relbaritems %} {% endblock %}
 44 |       </ul>
 45 |     </div>
 46 | {%- endmacro %}
 47 | 
 48 | {%- macro sidebar() %}
 49 |       {%- if render_sidebar %}
 50 |       <div class="sphinxsidebar">
 51 |         <div class="sphinxsidebarwrapper">
 52 |           {%- block sidebarlogo %}
 53 |           {%- if logo %}
 54 |             <p class="logo"><a href="{{ pathto(master_doc) }}">
 55 |               <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
 56 |             </a></p>
 57 |           {%- endif %}
 58 |           {%- endblock %}
 59 |           {%- if sidebars != None %}
 60 |             {#- new style sidebar: explicitly include/exclude templates #}
 61 |             {%- for sidebartemplate in sidebars %}
 62 |             {%- include sidebartemplate %}
 63 |             {%- endfor %}
 64 |           {%- else %}
 65 |             {#- old style sidebars: using blocks -- should be deprecated #}
 66 |             {%- block sidebartoc %}
 67 |             {%- include "localtoc.html" %}
 68 |             {%- endblock %}
 69 |             {%- block sidebarrel %}
 70 |             {%- include "relations.html" %}
 71 |             {%- endblock %}
 72 |             {%- block sidebarsourcelink %}
 73 |             {%- include "sourcelink.html" %}
 74 |             {%- endblock %}
 75 |             {%- if customsidebar %}
 76 |             {%- include customsidebar %}
 77 |             {%- endif %}
 78 |             {%- block sidebarsearch %}
 79 |             {%- include "searchbox.html" %}
 80 |             {%- endblock %}
 81 |           {%- endif %}
 82 |         </div>
 83 |       </div>
 84 |       {%- endif %}
 85 | {%- endmacro %}
 86 | 
 87 | {%- macro script() %}
 88 |     <script type="text/javascript">
 89 |       var DOCUMENTATION_OPTIONS = {
 90 |         URL_ROOT:    '{{ url_root }}',
 91 |         VERSION:     '{{ release|e }}',
 92 |         COLLAPSE_INDEX: false,
 93 |         FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
 94 |         HAS_SOURCE:  {{ has_source|lower }}
 95 |       };
 96 |     </script>
 97 |     {%- for scriptfile in script_files %}
 98 |     <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
 99 |     {%- endfor %}
100 | {%- endmacro %}
101 | 
102 | {%- macro css() %}
103 |     <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
104 |     <link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}" type="text/css" />
105 |     {%- for cssfile in css_files %}
106 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
107 |     {%- endfor %}
108 | {%- endmacro %}
109 | 
110 | <html xmlns="http://www.w3.org/1999/xhtml">
111 |   <head>
112 |     <meta http-equiv="Content-Type" content="text/html; charset={{ encoding }}" />
113 |     {{ metatags }}
114 |     {%- block htmltitle %}
115 |     <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
116 |     {%- endblock %}
117 |     {{ css() }}
118 |     {%- if not embedded %}
119 |     {{ script() }}
120 |     {%- if use_opensearch %}
121 |     <link rel="search" type="application/opensearchdescription+xml"
122 |           title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"
123 |           href="{{ pathto('_static/opensearch.xml', 1) }}"/>
124 |     {%- endif %}
125 |     {%- if favicon %}
126 |     <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
127 |     {%- endif %}
128 |     {%- endif %}
129 | {%- block linktags %}
130 |     {%- if hasdoc('about') %}
131 |     <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
132 |     {%- endif %}
133 |     {%- if hasdoc('genindex') %}
134 |     <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
135 |     {%- endif %}
136 |     {%- if hasdoc('search') %}
137 |     <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
138 |     {%- endif %}
139 |     {%- if hasdoc('copyright') %}
140 |     <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
141 |     {%- endif %}
142 |     <link rel="top" title="{{ docstitle|e }}" href="{{ pathto('index') }}" />
143 |     {%- if parents %}
144 |     <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}" />
145 |     {%- endif %}
146 |     {%- if next %}
147 |     <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
148 |     {%- endif %}
149 |     {%- if prev %}
150 |     <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
151 |     {%- endif %}
152 | {%- endblock %}
153 | {%- block extrahead %} {% endblock %}
154 |   </head>
155 |   <body>
156 | {%- block header %}{% endblock %}
157 | 
158 | {%- block relbar1 %}{{ relbar() }}{% endblock %}
159 | 
160 | {%- block content %}
161 |   {%- block sidebar1 %} {# possible location for sidebar #} {% endblock %}
162 | 
163 |     <div class="document">
164 |   {%- block document %}
165 |       <div class="documentwrapper">
166 |       {%- if render_sidebar %}
167 |         <div class="bodywrapper">
168 |       {%- endif %}
169 |           <div class="body">
170 |             {% block body %} {% endblock %}
171 |           </div>
172 |       {%- if render_sidebar %}
173 |         </div>
174 |       {%- endif %}
175 |       </div>
176 |   {%- endblock %}
177 | 
178 |   {%- block sidebar2 %}{{ sidebar() }}{% endblock %}
179 |       <div class="clearer"></div>
180 |     </div>
181 | {%- endblock %}
182 | 
183 | {%- block relbar2 %}{{ relbar() }}{% endblock %}
184 | 
185 | {%- block footer %}
186 |     <div class="footer">
187 |     {%- if show_copyright %}
188 |       {%- if hasdoc('copyright') %}
189 |         {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; <a href="{{ path }}">Copyright</a> {{ copyright }}.{% endtrans %}
190 |       {%- else %}
191 |         {% trans copyright=copyright|e %}&copy; Copyright {{ copyright }}.{% endtrans %}
192 |       {%- endif %}
193 |     {%- endif %}
194 |     {%- if last_updated %}
195 |       {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
196 |     {%- endif %}
197 |     {%- if show_sphinx %}
198 |       {% trans sphinx_version=sphinx_version|e %}Created using <a href="http://sphinx-doc.org/">Sphinx</a> {{ sphinx_version }}.{% endtrans %}
199 |     {%- endif %}
200 |     </div>
201 |     <p>asdf asdf asdf asdf 22</p>
202 | {%- endblock %}
203 |   </body>
204 | </html>
205 | 
206 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/search.html:
--------------------------------------------------------------------------------
 1 | {#
 2 |     basic/search.html
 3 |     ~~~~~~~~~~~~~~~~~
 4 | 
 5 |     Template for the search page.
 6 | 
 7 |     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
 8 |     :license: BSD, see LICENSE for details.
 9 | #}
10 | {%- extends "layout.html" %}
11 | {% set title = _('Search') %}
12 | {% set script_files = script_files + ['_static/searchtools.js'] %}
13 | {% block footer %}
14 |   <script type="text/javascript">
15 |     jQuery(function() { Search.loadIndex("{{ pathto('searchindex.js', 1) }}"); });
16 |   </script>
17 |   {# this is used when loading the search index using $.ajax fails,
18 |      such as on Chrome for documents on localhost #}
19 |   <script type="text/javascript" id="searchindexloader"></script>
20 |   {{ super() }}
21 | {% endblock %}
22 | {% block body %}
23 |   <noscript>
24 |   <div id="fallback" class="admonition warning">
25 |     <p class="last">
26 |       {% trans %}Please activate JavaScript to enable the search
27 |       functionality.{% endtrans %}
28 |     </p>
29 |   </div>
30 |   </noscript>
31 | 
32 |   {% if search_performed %}
33 |     <h2>{{ _('Search Results') }}</h2>
34 |     {% if not search_results %}
35 |       <p>{{ _('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.') }}</p>
36 |     {% endif %}
37 |   {% endif %}
38 |   <div id="search-results">
39 |   {% if search_results %}
40 |     <ul>
41 |     {% for href, caption, context in search_results %}
42 |       <li>
43 |         <a href="{{ pathto(item.href) }}">{{ caption }}</a>
44 |         <p class="context">{{ context|e }}</p>
45 |       </li>
46 |     {% endfor %}
47 |     </ul>
48 |   {% endif %}
49 |   </div>
50 | {% endblock %}
51 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/searchbox.html:
--------------------------------------------------------------------------------
 1 | {%- if builder != 'singlehtml' %}
 2 | <div role="search">
 3 |   <form id="rtd-search-form" class="wy-form" action="{{ pathto('search') }}" method="get">
 4 |     <input type="text" name="q" placeholder="Search docs" />
 5 |     <input type="hidden" name="check_keywords" value="yes" />
 6 |     <input type="hidden" name="area" value="default" />
 7 |   </form>
 8 | </div>
 9 | {%- endif %}
10 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-weight:normal;font-style:normal;src:url("../font/fontawesome_webfont.eot");src:url("../font/fontawesome_webfont.eot?#iefix") format("embedded-opentype"),url("../font/fontawesome_webfont.woff") format("woff"),url("../font/fontawesome_webfont.ttf") format("truetype"),url("../font/fontawesome_webfont.svg#FontAwesome") format("svg")}.fa:before{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;text-decoration:inherit}a .fa{display:inline-block;text-decoration:inherit}li .fa{display:inline-block}li .fa-large:before,li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-0.8em}ul.fas li .fa{width:0.8em}ul.fas li .fa-large:before,ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before{content:""}.icon-book:before{content:""}.fa-caret-down:before{content:""}.icon-caret-down:before{content:""}.fa-caret-up:before{content:""}.icon-caret-up:before{content:""}.fa-caret-left:before{content:""}.icon-caret-left:before{content:""}.fa-caret-right:before{content:""}.icon-caret-right:before{content:""}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;border-top:solid 10px #343131;font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;z-index:400}.rst-versions a{color:#2980B9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27AE60;*zoom:1}.rst-versions .rst-current-version:before,.rst-versions .rst-current-version:after{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book{float:left}.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#E74C3C;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#F1C40F;color:#000}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:gray;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:solid 1px #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px}.rst-versions.rst-badge .icon-book{float:none}.rst-versions.rst-badge .fa-book{float:none}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book{float:left}.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge .rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width: 768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}img{width:100%;height:auto}}
2 | /*# sourceMappingURL=badge_only.css.map */
3 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/css/badge_only.css.map:
--------------------------------------------------------------------------------
1 | {
2 | "version": 3,
3 | "mappings": "CAyDA,SAAY,EACV,qBAAsB,EAAE,UAAW,EAqDrC,QAAS,EARP,IAAK,EAAE,AAAC,EACR,+BAAS,EAEP,MAAO,EAAE,IAAK,EACd,MAAO,EAAE,CAAE,EACb,cAAO,EACL,IAAK,EAAE,GAAI,EC1Gb,SAkBC,EAjBC,UAAW,ECFJ,UAAW,EDGlB,UAAW,EAHqC,KAAM,EAItD,SAAU,EAJsD,KAAM,EAapE,EAAG,EAAE,qCAAwB,EAC7B,EAAG,EAAE,0PAAyE,ECZpF,SAAU,EACR,MAAO,EAAE,WAAY,EACrB,UAAW,EAAE,UAAW,EACxB,SAAU,EAAE,KAAM,EAClB,UAAW,EAAE,KAAM,EACnB,UAAW,EAAE,AAAC,EACd,cAAe,EAAE,MAAO,EAG1B,IAAK,EACH,MAAO,EAAE,WAAY,EACrB,cAAe,EAAE,MAAO,EAIxB,KAAG,EACD,MAAO,EAAE,WAAY,EACvB,sCAAiB,EAGf,IAAK,EAAE,MAAY,EAEvB,KAAM,EACJ,cAAe,EAAE,GAAI,EACrB,UAAW,EAAE,EAAG,EAChB,UAAW,EAAE,KAAM,EAEjB,YAAG,EACD,IAAK,EAAE,IAAI,EACb,oDAAiB,EAGf,aAAc,EAAE,OAAQ,EAG9B,cAAe,EACb,MAAO,EAAE,EAAO,EAElB,gBAAiB,EACf,MAAO,EAAE,EAAO,EAElB,oBAAqB,EACnB,MAAO,EAAE,EAAO,EAElB,sBAAuB,EACrB,MAAO,EAAE,EAAO,EAElB,kBAAmB,EACjB,MAAO,EAAE,EAAO,EAElB,oBAAqB,EACnB,MAAO,EAAE,EAAO,EAElB,oBAAqB,EACnB,MAAO,EAAE,EAAO,EAElB,sBAAuB,EACrB,MAAO,EAAE,EAAO,EAElB,qBAAsB,EACpB,MAAO,EAAE,EAAO,EAElB,uBAAwB,EACtB,MAAO,EAAE,EAAO,ECnElB,YAAa,EACX,OAAQ,EAAE,IAAK,EACf,KAAM,EAAE,AAAC,EACT,GAAI,EAAE,AAAC,EACP,IAAK,EC6E+B,IAAK,ED5EzC,IAAK,EEoC+B,MAAyB,EFnC7D,SAAU,EAAE,MAAkC,EAC9C,SAAU,EAAE,iBAAiC,EAC7C,UAAW,EE+CyB,sDAAM,EF9C1C,MAAO,EC+E6B,EAAG,ED9EvC,cAAC,EACC,IAAK,EE+B6B,MAAK,EF9BvC,cAAe,EAAE,GAAI,EACvB,6BAAgB,EACd,MAAO,EAAE,GAAI,EACf,iCAAoB,EAClB,MAAO,EAAE,GAAqB,EAC9B,eAAgB,EAAE,MAAkC,EACpD,MAAO,EAAE,IAAK,EACd,SAAU,EAAE,IAAK,EACjB,QAAS,EAAE,EAAG,EACd,KAAM,EAAE,MAAO,EACf,IAAK,EEX6B,MAAM,EL4F1C,IAAK,EAAE,AAAC,EACR,iFAAS,EAEP,MAAO,EAAE,IAAK,EACd,MAAO,EAAE,CAAE,EACb,uCAAO,EACL,IAAK,EAAE,GAAI,EGrFX,qCAAG,EACD,IAAK,EEgB2B,MAAyB,EFf3D,0CAAQ,EACN,IAAK,EAAE,GAAI,EACb,4CAAU,EACR,IAAK,EAAE,GAAI,EACb,iDAAiB,EACf,eAAgB,ECQgB,MAAI,EDPpC,IAAK,EEI2B,GAAM,EFHxC,wDAAwB,EACtB,eAAgB,EEmBgB,MAAO,EFlBvC,IAAK,ECzB2B,GAAI,ED0BxC,yCAA8B,EAC5B,MAAO,EAAE,IAAK,EAChB,gCAAmB,EACjB,QAAS,EAAE,EAAG,EACd,MAAO,EAAE,GAAqB,EAC9B,IAAK,EEP6B,GAAY,EFQ9C,MAAO,EAAE,GAAI,EACb,mCAAE,EACA,MAAO,EAAE,IAAK,EACd,KAAM,EAAE,EAAG,EACX,KAAM,EAAE,AAAC,EACT,KAAM,EAAE,KAAM,EACd,MAAO,EAAE,AAAC,EACV,SAAU,EAAE,gBAA6C,EAC3D,mCAAE,EACA,MAAO,EAAE,WAAY,EACrB,KAAM,EAAE,AAAC,EACT,qCAAC,EACC,MAAO,EAAE,WAAY,EACrB,MAAO,EAAE,EAAqB,EAC9B,IAAK,EEfyB,MAAyB,EFgB7D,sBAAW,EACT,IAAK,EAAE,GAAI,EACX,KAAM,EAAE,GAAI,EACZ,IAAK,EAAE,GAAI,EACX,GAAI,EAAE,GAAI,EACV,KAAM,EAAE,GAAI,EACZ,QAAS,ECkByB,IAAK,EDjBvC,iCAAU,EACR,IAAK,EAAE,GAAI,EACb,+BAAQ,EACN,IAAK,EAAE,GAAI,EACb,oDAA+B,EAC7B,SAAU,EAAE,IAAK,EACjB,6DAAQ,EACN,IAAK,EAAE,GAAI,EACb,+DAAU,EACR,IAAK,EAAE,GAAI,EACf,2CAAoB,EAClB,IAAK,EAAE,GAAI,EACX,KAAM,EAAE,GAAI,EACZ,UAAW,EAAE,GAAI,EACjB,MAAO,EAAE,IAAuB,EAChC,MAAO,EAAE,IAAK,EACd,SAAU,EAAE,KAAM,EGhDpB,mCAAsB,EHmDxB,YAAa,EACX,IAAK,EAAE,EAAG,EACV,MAAO,EAAE,GAAI,EACb,kBAAO,EACL,MAAO,EAAE,IAAK,EAClB,EAAG,EACD,IAAK,EAAE,GAAI,EACX,KAAM,EAAE,GAAI",
4 | "sources": ["../../../bower_components/wyrm/sass/wyrm_core/_mixin.sass","../../../bower_components/bourbon/dist/css3/_font-face.scss","../../../sass/_theme_badge_fa.sass","../../../sass/_theme_badge.sass","../../../bower_components/wyrm/sass/wyrm_core/_wy_variables.sass","../../../sass/_theme_variables.sass","../../../bower_components/neat/app/assets/stylesheets/grid/_media.scss"],
5 | "names": [],
6 | "file": "badge_only.css"
7 | }
8 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/FontAwesome.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/FontAwesome.otf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Bold.ttf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Regular.ttf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/Lato-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/Lato-Bold.ttf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/Lato-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/Lato-Regular.ttf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Bold.ttf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Regular.ttf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/doc/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/js/modernizr.min.js:
--------------------------------------------------------------------------------
1 | /* Modernizr 2.6.2 (Custom Build) | MIT & BSD
2 |  * Build: http://modernizr.com/download/#-fontface-backgroundsize-borderimage-borderradius-boxshadow-flexbox-hsla-multiplebgs-opacity-rgba-textshadow-cssanimations-csscolumns-generatedcontent-cssgradients-cssreflections-csstransforms-csstransforms3d-csstransitions-applicationcache-canvas-canvastext-draganddrop-hashchange-history-audio-video-indexeddb-input-inputtypes-localstorage-postmessage-sessionstorage-websockets-websqldatabase-webworkers-geolocation-inlinesvg-smil-svg-svgclippaths-touch-webgl-shiv-mq-cssclasses-addtest-prefixed-teststyles-testprop-testallprops-hasevent-prefixes-domprefixes-load
3 |  */
4 | ;window.Modernizr=function(a,b,c){function D(a){j.cssText=a}function E(a,b){return D(n.join(a+";")+(b||""))}function F(a,b){return typeof a===b}function G(a,b){return!!~(""+a).indexOf(b)}function H(a,b){for(var d in a){var e=a[d];if(!G(e,"-")&&j[e]!==c)return b=="pfx"?e:!0}return!1}function I(a,b,d){for(var e in a){var f=b[a[e]];if(f!==c)return d===!1?a[e]:F(f,"function")?f.bind(d||b):f}return!1}function J(a,b,c){var d=a.charAt(0).toUpperCase()+a.slice(1),e=(a+" "+p.join(d+" ")+d).split(" ");return F(b,"string")||F(b,"undefined")?H(e,b):(e=(a+" "+q.join(d+" ")+d).split(" "),I(e,b,c))}function K(){e.input=function(c){for(var d=0,e=c.length;d<e;d++)u[c[d]]=c[d]in k;return u.list&&(u.list=!!b.createElement("datalist")&&!!a.HTMLDataListElement),u}("autocomplete autofocus list placeholder max min multiple pattern required step".split(" ")),e.inputtypes=function(a){for(var d=0,e,f,h,i=a.length;d<i;d++)k.setAttribute("type",f=a[d]),e=k.type!=="text",e&&(k.value=l,k.style.cssText="position:absolute;visibility:hidden;",/^range$/.test(f)&&k.style.WebkitAppearance!==c?(g.appendChild(k),h=b.defaultView,e=h.getComputedStyle&&h.getComputedStyle(k,null).WebkitAppearance!=="textfield"&&k.offsetHeight!==0,g.removeChild(k)):/^(search|tel)$/.test(f)||(/^(url|email)$/.test(f)?e=k.checkValidity&&k.checkValidity()===!1:e=k.value!=l)),t[a[d]]=!!e;return t}("search tel url email datetime date month week time datetime-local number range color".split(" "))}var d="2.6.2",e={},f=!0,g=b.documentElement,h="modernizr",i=b.createElement(h),j=i.style,k=b.createElement("input"),l=":)",m={}.toString,n=" -webkit- -moz- -o- -ms- ".split(" "),o="Webkit Moz O ms",p=o.split(" "),q=o.toLowerCase().split(" "),r={svg:"http://www.w3.org/2000/svg"},s={},t={},u={},v=[],w=v.slice,x,y=function(a,c,d,e){var f,i,j,k,l=b.createElement("div"),m=b.body,n=m||b.createElement("body");if(parseInt(d,10))while(d--)j=b.createElement("div"),j.id=e?e[d]:h+(d+1),l.appendChild(j);return f=["&#173;",'<style id="s',h,'">',a,"</style>"].join(""),l.id=h,(m?l:n).innerHTML+=f,n.appendChild(l),m||(n.style.background="",n.style.overflow="hidden",k=g.style.overflow,g.style.overflow="hidden",g.appendChild(n)),i=c(l,a),m?l.parentNode.removeChild(l):(n.parentNode.removeChild(n),g.style.overflow=k),!!i},z=function(b){var c=a.matchMedia||a.msMatchMedia;if(c)return c(b).matches;var d;return y("@media "+b+" { #"+h+" { position: absolute; } }",function(b){d=(a.getComputedStyle?getComputedStyle(b,null):b.currentStyle)["position"]=="absolute"}),d},A=function(){function d(d,e){e=e||b.createElement(a[d]||"div"),d="on"+d;var f=d in e;return f||(e.setAttribute||(e=b.createElement("div")),e.setAttribute&&e.removeAttribute&&(e.setAttribute(d,""),f=F(e[d],"function"),F(e[d],"undefined")||(e[d]=c),e.removeAttribute(d))),e=null,f}var a={select:"input",change:"input",submit:"form",reset:"form",error:"img",load:"img",abort:"img"};return d}(),B={}.hasOwnProperty,C;!F(B,"undefined")&&!F(B.call,"undefined")?C=function(a,b){return B.call(a,b)}:C=function(a,b){return b in a&&F(a.constructor.prototype[b],"undefined")},Function.prototype.bind||(Function.prototype.bind=function(b){var c=this;if(typeof c!="function")throw new TypeError;var d=w.call(arguments,1),e=function(){if(this instanceof e){var a=function(){};a.prototype=c.prototype;var f=new a,g=c.apply(f,d.concat(w.call(arguments)));return Object(g)===g?g:f}return c.apply(b,d.concat(w.call(arguments)))};return e}),s.flexbox=function(){return J("flexWrap")},s.canvas=function(){var a=b.createElement("canvas");return!!a.getContext&&!!a.getContext("2d")},s.canvastext=function(){return!!e.canvas&&!!F(b.createElement("canvas").getContext("2d").fillText,"function")},s.webgl=function(){return!!a.WebGLRenderingContext},s.touch=function(){var c;return"ontouchstart"in a||a.DocumentTouch&&b instanceof DocumentTouch?c=!0:y(["@media (",n.join("touch-enabled),("),h,")","{#modernizr{top:9px;position:absolute}}"].join(""),function(a){c=a.offsetTop===9}),c},s.geolocation=function(){return"geolocation"in navigator},s.postmessage=function(){return!!a.postMessage},s.websqldatabase=function(){return!!a.openDatabase},s.indexedDB=function(){return!!J("indexedDB",a)},s.hashchange=function(){return A("hashchange",a)&&(b.documentMode===c||b.documentMode>7)},s.history=function(){return!!a.history&&!!history.pushState},s.draganddrop=function(){var a=b.createElement("div");return"draggable"in a||"ondragstart"in a&&"ondrop"in a},s.websockets=function(){return"WebSocket"in a||"MozWebSocket"in a},s.rgba=function(){return D("background-color:rgba(150,255,150,.5)"),G(j.backgroundColor,"rgba")},s.hsla=function(){return D("background-color:hsla(120,40%,100%,.5)"),G(j.backgroundColor,"rgba")||G(j.backgroundColor,"hsla")},s.multiplebgs=function(){return D("background:url(https://),url(https://),red url(https://)"),/(url\s*\(.*?){3}/.test(j.background)},s.backgroundsize=function(){return J("backgroundSize")},s.borderimage=function(){return J("borderImage")},s.borderradius=function(){return J("borderRadius")},s.boxshadow=function(){return J("boxShadow")},s.textshadow=function(){return b.createElement("div").style.textShadow===""},s.opacity=function(){return E("opacity:.55"),/^0.55$/.test(j.opacity)},s.cssanimations=function(){return J("animationName")},s.csscolumns=function(){return J("columnCount")},s.cssgradients=function(){var a="background-image:",b="gradient(linear,left top,right bottom,from(#9f9),to(white));",c="linear-gradient(left top,#9f9, white);";return D((a+"-webkit- ".split(" ").join(b+a)+n.join(c+a)).slice(0,-a.length)),G(j.backgroundImage,"gradient")},s.cssreflections=function(){return J("boxReflect")},s.csstransforms=function(){return!!J("transform")},s.csstransforms3d=function(){var a=!!J("perspective");return a&&"webkitPerspective"in g.style&&y("@media (transform-3d),(-webkit-transform-3d){#modernizr{left:9px;position:absolute;height:3px;}}",function(b,c){a=b.offsetLeft===9&&b.offsetHeight===3}),a},s.csstransitions=function(){return J("transition")},s.fontface=function(){var a;return y('@font-face {font-family:"font";src:url("https://")}',function(c,d){var e=b.getElementById("smodernizr"),f=e.sheet||e.styleSheet,g=f?f.cssRules&&f.cssRules[0]?f.cssRules[0].cssText:f.cssText||"":"";a=/src/i.test(g)&&g.indexOf(d.split(" ")[0])===0}),a},s.generatedcontent=function(){var a;return y(["#",h,"{font:0/0 a}#",h,':after{content:"',l,'";visibility:hidden;font:3px/1 a}'].join(""),function(b){a=b.offsetHeight>=3}),a},s.video=function(){var a=b.createElement("video"),c=!1;try{if(c=!!a.canPlayType)c=new Boolean(c),c.ogg=a.canPlayType('video/ogg; codecs="theora"').replace(/^no$/,""),c.h264=a.canPlayType('video/mp4; codecs="avc1.42E01E"').replace(/^no$/,""),c.webm=a.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/,"")}catch(d){}return c},s.audio=function(){var a=b.createElement("audio"),c=!1;try{if(c=!!a.canPlayType)c=new Boolean(c),c.ogg=a.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/,""),c.mp3=a.canPlayType("audio/mpeg;").replace(/^no$/,""),c.wav=a.canPlayType('audio/wav; codecs="1"').replace(/^no$/,""),c.m4a=(a.canPlayType("audio/x-m4a;")||a.canPlayType("audio/aac;")).replace(/^no$/,"")}catch(d){}return c},s.localstorage=function(){try{return localStorage.setItem(h,h),localStorage.removeItem(h),!0}catch(a){return!1}},s.sessionstorage=function(){try{return sessionStorage.setItem(h,h),sessionStorage.removeItem(h),!0}catch(a){return!1}},s.webworkers=function(){return!!a.Worker},s.applicationcache=function(){return!!a.applicationCache},s.svg=function(){return!!b.createElementNS&&!!b.createElementNS(r.svg,"svg").createSVGRect},s.inlinesvg=function(){var a=b.createElement("div");return a.innerHTML="<svg/>",(a.firstChild&&a.firstChild.namespaceURI)==r.svg},s.smil=function(){return!!b.createElementNS&&/SVGAnimate/.test(m.call(b.createElementNS(r.svg,"animate")))},s.svgclippaths=function(){return!!b.createElementNS&&/SVGClipPath/.test(m.call(b.createElementNS(r.svg,"clipPath")))};for(var L in s)C(s,L)&&(x=L.toLowerCase(),e[x]=s[L](),v.push((e[x]?"":"no-")+x));return e.input||K(),e.addTest=function(a,b){if(typeof a=="object")for(var d in a)C(a,d)&&e.addTest(d,a[d]);else{a=a.toLowerCase();if(e[a]!==c)return e;b=typeof b=="function"?b():b,typeof f!="undefined"&&f&&(g.className+=" "+(b?"":"no-")+a),e[a]=b}return e},D(""),i=k=null,function(a,b){function k(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function l(){var a=r.elements;return typeof a=="string"?a.split(" "):a}function m(a){var b=i[a[g]];return b||(b={},h++,a[g]=h,i[h]=b),b}function n(a,c,f){c||(c=b);if(j)return c.createElement(a);f||(f=m(c));var g;return f.cache[a]?g=f.cache[a].cloneNode():e.test(a)?g=(f.cache[a]=f.createElem(a)).cloneNode():g=f.createElem(a),g.canHaveChildren&&!d.test(a)?f.frag.appendChild(g):g}function o(a,c){a||(a=b);if(j)return a.createDocumentFragment();c=c||m(a);var d=c.frag.cloneNode(),e=0,f=l(),g=f.length;for(;e<g;e++)d.createElement(f[e]);return d}function p(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return r.shivMethods?n(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+l().join().replace(/\w+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(r,b.frag)}function q(a){a||(a=b);var c=m(a);return r.shivCSS&&!f&&!c.hasCSS&&(c.hasCSS=!!k(a,"article,aside,figcaption,figure,footer,header,hgroup,nav,section{display:block}mark{background:#FF0;color:#000}")),j||p(a,c),a}var c=a.html5||{},d=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,e=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,f,g="_html5shiv",h=0,i={},j;(function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",f="hidden"in a,j=a.childNodes.length==1||function(){b.createElement("a");var a=b.createDocumentFragment();return typeof a.cloneNode=="undefined"||typeof a.createDocumentFragment=="undefined"||typeof a.createElement=="undefined"}()}catch(c){f=!0,j=!0}})();var r={elements:c.elements||"abbr article aside audio bdi canvas data datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video",shivCSS:c.shivCSS!==!1,supportsUnknownElements:j,shivMethods:c.shivMethods!==!1,type:"default",shivDocument:q,createElement:n,createDocumentFragment:o};a.html5=r,q(b)}(this,b),e._version=d,e._prefixes=n,e._domPrefixes=q,e._cssomPrefixes=p,e.mq=z,e.hasEvent=A,e.testProp=function(a){return H([a])},e.testAllProps=J,e.testStyles=y,e.prefixed=function(a,b,c){return b?J(a,b,c):J(a,"pfx")},g.className=g.className.replace(/(^|\s)no-js(\s|$)/,"$1$2")+(f?" js "+v.join(" "):""),e}(this,this.document),function(a,b,c){function d(a){return"[object Function]"==o.call(a)}function e(a){return"string"==typeof a}function f(){}function g(a){return!a||"loaded"==a||"complete"==a||"uninitialized"==a}function h(){var a=p.shift();q=1,a?a.t?m(function(){("c"==a.t?B.injectCss:B.injectJs)(a.s,0,a.a,a.x,a.e,1)},0):(a(),h()):q=0}function i(a,c,d,e,f,i,j){function k(b){if(!o&&g(l.readyState)&&(u.r=o=1,!q&&h(),l.onload=l.onreadystatechange=null,b)){"img"!=a&&m(function(){t.removeChild(l)},50);for(var d in y[c])y[c].hasOwnProperty(d)&&y[c][d].onload()}}var j=j||B.errorTimeout,l=b.createElement(a),o=0,r=0,u={t:d,s:c,e:f,a:i,x:j};1===y[c]&&(r=1,y[c]=[]),"object"==a?l.data=c:(l.src=c,l.type=a),l.width=l.height="0",l.onerror=l.onload=l.onreadystatechange=function(){k.call(this,r)},p.splice(e,0,u),"img"!=a&&(r||2===y[c]?(t.insertBefore(l,s?null:n),m(k,j)):y[c].push(l))}function j(a,b,c,d,f){return q=0,b=b||"j",e(a)?i("c"==b?v:u,a,b,this.i++,c,d,f):(p.splice(this.i++,0,a),1==p.length&&h()),this}function k(){var a=B;return a.loader={load:j,i:0},a}var l=b.documentElement,m=a.setTimeout,n=b.getElementsByTagName("script")[0],o={}.toString,p=[],q=0,r="MozAppearance"in l.style,s=r&&!!b.createRange().compareNode,t=s?l:n.parentNode,l=a.opera&&"[object Opera]"==o.call(a.opera),l=!!b.attachEvent&&!l,u=r?"object":l?"script":"img",v=l?"script":u,w=Array.isArray||function(a){return"[object Array]"==o.call(a)},x=[],y={},z={timeout:function(a,b){return b.length&&(a.timeout=b[0]),a}},A,B;B=function(a){function b(a){var a=a.split("!"),b=x.length,c=a.pop(),d=a.length,c={url:c,origUrl:c,prefixes:a},e,f,g;for(f=0;f<d;f++)g=a[f].split("="),(e=z[g.shift()])&&(c=e(c,g));for(f=0;f<b;f++)c=x[f](c);return c}function g(a,e,f,g,h){var i=b(a),j=i.autoCallback;i.url.split(".").pop().split("?").shift(),i.bypass||(e&&(e=d(e)?e:e[a]||e[g]||e[a.split("/").pop().split("?")[0]]),i.instead?i.instead(a,e,f,g,h):(y[i.url]?i.noexec=!0:y[i.url]=1,f.load(i.url,i.forceCSS||!i.forceJS&&"css"==i.url.split(".").pop().split("?").shift()?"c":c,i.noexec,i.attrs,i.timeout),(d(e)||d(j))&&f.load(function(){k(),e&&e(i.origUrl,h,g),j&&j(i.origUrl,h,g),y[i.url]=2})))}function h(a,b){function c(a,c){if(a){if(e(a))c||(j=function(){var a=[].slice.call(arguments);k.apply(this,a),l()}),g(a,j,b,0,h);else if(Object(a)===a)for(n in m=function(){var b=0,c;for(c in a)a.hasOwnProperty(c)&&b++;return b}(),a)a.hasOwnProperty(n)&&(!c&&!--m&&(d(j)?j=function(){var a=[].slice.call(arguments);k.apply(this,a),l()}:j[n]=function(a){return function(){var b=[].slice.call(arguments);a&&a.apply(this,b),l()}}(k[n])),g(a[n],j,b,n,h))}else!c&&l()}var h=!!a.test,i=a.load||a.both,j=a.callback||f,k=j,l=a.complete||f,m,n;c(h?a.yep:a.nope,!!i),i&&c(i)}var i,j,l=this.yepnope.loader;if(e(a))g(a,0,l,0);else if(w(a))for(i=0;i<a.length;i++)j=a[i],e(j)?g(j,0,l,0):w(j)?B(j):Object(j)===j&&h(j,l);else Object(a)===a&&h(a,l)},B.addPrefix=function(a,b){z[a]=b},B.addFilter=function(a){x.push(a)},B.errorTimeout=1e4,null==b.readyState&&b.addEventListener&&(b.readyState="loading",b.addEventListener("DOMContentLoaded",A=function(){b.removeEventListener("DOMContentLoaded",A,0),b.readyState="complete"},0)),a.yepnope=k(),a.yepnope.executeStack=h,a.yepnope.injectJs=function(a,c,d,e,i,j){var k=b.createElement("script"),l,o,e=e||B.errorTimeout;k.src=a;for(o in d)k.setAttribute(o,d[o]);c=j?h:c||f,k.onreadystatechange=k.onload=function(){!l&&g(k.readyState)&&(l=1,c(),k.onload=k.onreadystatechange=null)},m(function(){l||(l=1,c(1))},e),i?k.onload():n.parentNode.insertBefore(k,n)},a.yepnope.injectCss=function(a,c,d,e,g,i){var e=b.createElement("link"),j,c=i?h:c||f;e.href=a,e.rel="stylesheet",e.type="text/css";for(j in d)e.setAttribute(j,d[j]);g||(n.parentNode.insertBefore(e,n),m(c,0))}}(this,document),Modernizr.load=function(){yepnope.apply(window,[].slice.call(arguments,0))};
5 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/static/js/theme.js:
--------------------------------------------------------------------------------
  1 | require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"sphinx-rtd-theme":[function(require,module,exports){
  2 | var jQuery = (typeof(window) != 'undefined') ? window.jQuery : require('jquery');
  3 | 
  4 | // Sphinx theme nav state
  5 | function ThemeNav () {
  6 | 
  7 |     var nav = {
  8 |         navBar: null,
  9 |         win: null,
 10 |         winScroll: false,
 11 |         winResize: false,
 12 |         linkScroll: false,
 13 |         winPosition: 0,
 14 |         winHeight: null,
 15 |         docHeight: null,
 16 |         isRunning: false
 17 |     };
 18 | 
 19 |     nav.enable = function () {
 20 |         var self = this;
 21 | 
 22 |         if (!self.isRunning) {
 23 |             self.isRunning = true;
 24 |             jQuery(function ($) {
 25 |                 self.init($);
 26 | 
 27 |                 self.reset();
 28 |                 self.win.on('hashchange', self.reset);
 29 | 
 30 |                 // Set scroll monitor
 31 |                 self.win.on('scroll', function () {
 32 |                     if (!self.linkScroll) {
 33 |                         self.winScroll = true;
 34 |                     }
 35 |                 });
 36 |                 setInterval(function () { if (self.winScroll) self.onScroll(); }, 25);
 37 | 
 38 |                 // Set resize monitor
 39 |                 self.win.on('resize', function () {
 40 |                     self.winResize = true;
 41 |                 });
 42 |                 setInterval(function () { if (self.winResize) self.onResize(); }, 25);
 43 |                 self.onResize();
 44 |             });
 45 |         };
 46 |     };
 47 | 
 48 |     nav.init = function ($) {
 49 |         var doc = $(document),
 50 |             self = this;
 51 | 
 52 |         this.navBar = $('div.wy-side-scroll:first');
 53 |         this.win = $(window);
 54 | 
 55 |         // Set up javascript UX bits
 56 |         $(document)
 57 |             // Shift nav in mobile when clicking the menu.
 58 |             .on('click', "[data-toggle='wy-nav-top']", function() {
 59 |                 $("[data-toggle='wy-nav-shift']").toggleClass("shift");
 60 |                 $("[data-toggle='rst-versions']").toggleClass("shift");
 61 |             })
 62 | 
 63 |             // Nav menu link click operations
 64 |             .on('click', ".wy-menu-vertical .current ul li a", function() {
 65 |                 var target = $(this);
 66 |                 // Close menu when you click a link.
 67 |                 $("[data-toggle='wy-nav-shift']").removeClass("shift");
 68 |                 $("[data-toggle='rst-versions']").toggleClass("shift");
 69 |                 // Handle dynamic display of l3 and l4 nav lists
 70 |                 self.toggleCurrent(target);
 71 |                 self.hashChange();
 72 |             })
 73 |             .on('click', "[data-toggle='rst-current-version']", function() {
 74 |                 $("[data-toggle='rst-versions']").toggleClass("shift-up");
 75 |             })
 76 | 
 77 |         // Make tables responsive
 78 |         $("table.docutils:not(.field-list)")
 79 |             .wrap("<div class='wy-table-responsive'></div>");
 80 | 
 81 |         // Add expand links to all parents of nested ul
 82 |         $('.wy-menu-vertical ul').not('.simple').siblings('a').each(function () {
 83 |             var link = $(this);
 84 |                 expand = $('<span class="toctree-expand"></span>');
 85 |             expand.on('click', function (ev) {
 86 |                 self.toggleCurrent(link);
 87 |                 ev.stopPropagation();
 88 |                 return false;
 89 |             });
 90 |             link.prepend(expand);
 91 |         });
 92 |     };
 93 | 
 94 |     nav.reset = function () {
 95 |         // Get anchor from URL and open up nested nav
 96 |         var anchor = encodeURI(window.location.hash);
 97 |         if (anchor) {
 98 |             try {
 99 |                 var link = $('.wy-menu-vertical')
100 |                     .find('[href="' + anchor + '"]');
101 |                 $('.wy-menu-vertical li.toctree-l1 li.current')
102 |                     .removeClass('current');
103 |                 link.closest('li.toctree-l2').addClass('current');
104 |                 link.closest('li.toctree-l3').addClass('current');
105 |                 link.closest('li.toctree-l4').addClass('current');
106 |             }
107 |             catch (err) {
108 |                 console.log("Error expanding nav for anchor", err);
109 |             }
110 |         }
111 |     };
112 | 
113 |     nav.onScroll = function () {
114 |         this.winScroll = false;
115 |         var newWinPosition = this.win.scrollTop(),
116 |             winBottom = newWinPosition + this.winHeight,
117 |             navPosition = this.navBar.scrollTop(),
118 |             newNavPosition = navPosition + (newWinPosition - this.winPosition);
119 |         if (newWinPosition < 0 || winBottom > this.docHeight) {
120 |             return;
121 |         }
122 |         this.navBar.scrollTop(newNavPosition);
123 |         this.winPosition = newWinPosition;
124 |     };
125 | 
126 |     nav.onResize = function () {
127 |         this.winResize = false;
128 |         this.winHeight = this.win.height();
129 |         this.docHeight = $(document).height();
130 |     };
131 | 
132 |     nav.hashChange = function () {
133 |         this.linkScroll = true;
134 |         this.win.one('hashchange', function () {
135 |             this.linkScroll = false;
136 |         });
137 |     };
138 | 
139 |     nav.toggleCurrent = function (elem) {
140 |         var parent_li = elem.closest('li');
141 |         parent_li.siblings('li.current').removeClass('current');
142 |         parent_li.siblings().find('li.current').removeClass('current');
143 |         parent_li.find('> ul li.current').removeClass('current');
144 |         parent_li.toggleClass('current');
145 |     }
146 | 
147 |     return nav;
148 | };
149 | 
150 | module.exports.ThemeNav = ThemeNav();
151 | 
152 | if (typeof(window) != 'undefined') {
153 |     window.SphinxRtdTheme = { StickyNav: module.exports.ThemeNav };
154 | }
155 | 
156 | },{"jquery":"jquery"}]},{},["sphinx-rtd-theme"]);
157 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/theme.conf:
--------------------------------------------------------------------------------
 1 | [theme]
 2 | inherit = basic
 3 | stylesheet = css/theme.css
 4 | 
 5 | [options]
 6 | typekit_id = hiw1hhg
 7 | analytics_id = 
 8 | sticky_navigation = False
 9 | logo_only =
10 | collapse_navigation = False
11 | display_version = True
12 | 


--------------------------------------------------------------------------------
/doc/_themes/sphinx_rtd_theme/versions.html:
--------------------------------------------------------------------------------
 1 | {% if READTHEDOCS %}
 2 | {# Add rst-badge after rst-versions for small badge style. #}
 3 |   <div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
 4 |     <span class="rst-current-version" data-toggle="rst-current-version">
 5 |       <span class="fa fa-book"> Read the Docs</span>
 6 |       v: {{ current_version }}
 7 |       <span class="fa fa-caret-down"></span>
 8 |     </span>
 9 |     <div class="rst-other-versions">
10 |       <dl>
11 |         <dt>Versions</dt>
12 |         {% for slug, url in versions %}
13 |           <dd><a href="{{ url }}">{{ slug }}</a></dd>
14 |         {% endfor %}
15 |       </dl>
16 |       <dl>
17 |         <dt>Downloads</dt>
18 |         {% for type, url in downloads %}
19 |           <dd><a href="{{ url }}">{{ type }}</a></dd>
20 |         {% endfor %}
21 |       </dl>
22 |       <dl>
23 |         <dt>On Read the Docs</dt>
24 |           <dd>
25 |             <a href="//{{ PRODUCTION_DOMAIN }}/projects/{{ slug }}/?fromdocs={{ slug }}">Project Home</a>
26 |           </dd>
27 |           <dd>
28 |             <a href="//{{ PRODUCTION_DOMAIN }}/builds/{{ slug }}/?fromdocs={{ slug }}">Builds</a>
29 |           </dd>
30 |       </dl>
31 |       <hr/>
32 |       Free document hosting provided by <a href="http://www.readthedocs.org">Read the Docs</a>.
33 | 
34 |     </div>
35 |   </div>
36 | {% endif %}
37 | 
38 | 


--------------------------------------------------------------------------------
/doc/api.rst:
--------------------------------------------------------------------------------
 1 | .. _api_documentation:
 2 | 
 3 | =================
 4 | API Documentation
 5 | =================
 6 | 
 7 | .. currentmodule:: pyglmnet
 8 | 
 9 | Classes
10 | =======
11 | 
12 | .. autoclass:: GLM
13 |    :members:
14 | 
15 | .. autoclass:: GLMCV
16 |   :members:
17 | 
18 | 
19 | Datasets
20 | ========
21 | 
22 | Functions to download the dataset
23 | 
24 | .. autofunction:: fetch_community_crime_data
25 | .. autofunction:: fetch_group_lasso_data
26 | .. autofunction:: fetch_tikhonov_data
27 | .. autofunction:: fetch_rgc_spike_trains


--------------------------------------------------------------------------------
/doc/cheatsheet.rst:
--------------------------------------------------------------------------------
  1 | ==========
  2 | Cheatsheet
  3 | ==========
  4 | 
  5 | This is a simple cheatsheet with the gradients and Hessians
  6 | of the penalized log likelihood loss to use as updates in the
  7 | Newton coordinate descent algorithm for GLMs.
  8 | 
  9 | Poisson: `softplus`
 10 | -------------------
 11 | 
 12 | **Mean Function**
 13 | 
 14 | .. math::
 15 | 
 16 |     z_i &= \beta_0 + \sum_j \beta_j x_{ij} \\
 17 |     \mu_i &= \log( 1 + \exp(z_i) )
 18 | 
 19 | **Log-likelihood function**
 20 | 
 21 | .. math::
 22 | 
 23 |     \mathcal{L} = \sum_i y_i \log(\mu_i) - \sum_i \mu_i
 24 | 
 25 | **L2-penalized loss function**
 26 | 
 27 | .. math::
 28 | 
 29 |     J &= \frac{1}{n}\sum_i \left\{ \log( 1 + \exp( \beta_0 + \sum_j \beta_j x_{ij} ) ) \right\} \\
 30 |     &- \frac{1}{n}\sum_i \left\{ y_i \log( \log( 1 + \exp(\beta_0 + \sum_j \beta_j x_{ij} ) ) ) \right\} \\
 31 |     &+ \lambda (1-\alpha) \frac{1}{2} \sum_j \beta_j^2
 32 | 
 33 | **Gradient**
 34 | 
 35 | .. math::
 36 | 
 37 |     \mu(z_i) &= \log(1 + \exp(z_i)) \\
 38 |     \sigma(z_i) &= \frac{1}{1 + \exp(-z_i)} \\
 39 |     \frac{\partial J}{\partial \beta_0} &= \frac{1}{n}\sum_i \sigma(z_i) - \frac{1}{n}\sum_i y_i \frac{\sigma(z_i)}{\mu(z_i)} \\
 40 |     \frac{\partial J}{\partial \beta_j} &= \frac{1}{n}\sum_i \sigma(z_i) x_{ij} - \frac{1}{n}\sum_i \sigma(z_i) y_i \frac{\sigma(z_i)}{\mu(z_i)}x_{ij} + \lambda (1 - \alpha) \beta_j
 41 | 
 42 | **Hessian**
 43 | 
 44 | .. math::
 45 | 
 46 |     \mu(z_i) &= \log(1 + \exp(z_i)) \\
 47 |     \sigma(z_i) &= \frac{1}{1 + \exp(-z_i)} \\
 48 |     \frac{\partial^2 J}{\partial \beta_0^2} &= \frac{1}{n}\sum_i \sigma(z_i) (1 - \sigma(z_i))
 49 |     - \frac{1}{n}\sum_i y_i \left\{ \frac{\sigma(z_i) (1 - \sigma(z_i))}{\mu(z_i)} - \frac{\sigma(z_i)}{\mu(z_i)^2} \right\} \\
 50 |     \frac{\partial^2 J}{\partial \beta_j^2} &=  \frac{1}{n}\sum_i \sigma(z_i) (1 - \sigma(z_i)) x_{ij}^2
 51 |     - \frac{1}{n}\sum_i y_i \left\{ \frac{\sigma(z_i) (1 - \sigma(z_i))}{\mu(z_i)} - \frac{\sigma(z_i)}{\mu(z_i)^2} \right\} x_{ij}^2
 52 |     + \lambda (1 - \alpha)
 53 | 
 54 | Poisson (linearized): `poisson`
 55 | -------------------------------
 56 | 
 57 | **Mean Function**
 58 | 
 59 | .. math::
 60 | 
 61 |     z_i &= \beta_0 + \sum_j \beta_j x_{ij} \\
 62 |     \mu_i &=
 63 |     \begin{cases}
 64 |     \exp(z_i), & z_i \leq \eta \\
 65 |     \\
 66 |     \exp(\eta)z_i + (1-\eta)\exp(\eta), & z_i > \eta
 67 |     \end{cases}
 68 | 
 69 | **Log-likelihood function**
 70 | 
 71 | .. math::
 72 | 
 73 |   \mathcal{L} = \sum_i y_i \log(\mu_i) - \sum_i \mu_i
 74 | 
 75 | **L2-penalized loss function**
 76 | 
 77 | .. math::
 78 | 
 79 |     J = -\frac{1}{n} \mathcal{L} + \lambda (1 - \alpha) \frac{1}{2} \sum_j \beta_j^2
 80 | 
 81 | **Gradient**
 82 | 
 83 | .. math::
 84 | 
 85 |     \mu_i &=
 86 |     \begin{cases}
 87 |     \exp(z_i),  & z_i \leq \eta \\
 88 |     \\
 89 |     \exp(\eta)z_i + (1-\eta)\exp(\eta),  & z_i > \eta
 90 |     \end{cases}
 91 |     \\
 92 |     \frac{\partial J}{\partial \beta_0} &= \frac{1}{n}\sum_{i; z_i \leq \eta} (\mu_i - y_i)
 93 |     + \frac{1}{n}\sum_{i; z_i > \eta} \exp(\eta) (1 - y_i/\mu_i) \\
 94 |     \frac{\partial J}{\partial \beta_j} &= \frac{1}{n}\sum_{i; z_i \leq \eta} (\mu_i - y_i) x_{ij}
 95 |     + \frac{1}{n}\sum_{i; z_i > \eta} \exp(\eta) (1 - y_i/\mu_i) x_{ij}
 96 | 
 97 | **Hessian**
 98 | 
 99 | .. math::
100 | 
101 |     \mu_i &=
102 |     \begin{cases}
103 |     \exp(z_i),  & z_i \leq \eta \\
104 |     \\
105 |     \exp(\eta)z_i + (1-\eta)\exp(\eta),  & z_i > \eta
106 |     \end{cases}
107 |     \\
108 |     \frac{\partial^2 J}{\partial \beta_0^2} &= \frac{1}{n}\sum_{i; z_i \leq \eta} \mu_i
109 |     + \frac{1}{n}\sum_{i; z_i > \eta} \exp(\eta)^2 \frac{y_i}{\mu_i^2}  \\
110 |     \frac{\partial^2 J}{\partial \beta_j^2} &=  \frac{1}{n}\sum_{i; z_i \leq \eta} \mu_i x_{ij}^2
111 |     + \frac{1}{n}\sum_{i; z_i > \eta} \exp(\eta)^2 \frac{y_i}{\mu_i^2} x_{ij}^2
112 |     + \lambda (1 - \alpha)
113 | 
114 | Gaussian: `gaussian`
115 | --------------------
116 | 
117 | **Mean Function**
118 | 
119 | .. math::
120 | 
121 |     z_i &= \beta_0 + \sum_j \beta_j x_{ij} \\
122 |     \mu_i &= z_i
123 | 
124 | **Log-likelihood function**
125 | 
126 | .. math::
127 | 
128 |     \mathcal{L} = -\frac{1}{2} \sum_i (y_i - \mu_i)^2 \\
129 | 
130 | **L2-penalized loss function**
131 | 
132 | .. math::
133 | 
134 |     J = \frac{1}{2n}\sum_i (y_i - (\beta_0 + \sum_j \beta_j x_{ij}))^2 +
135 |     \lambda (1 - \alpha) \frac{1}{2}\sum_j \beta_j^2\\
136 | 
137 | **Gradient**
138 | 
139 | .. math::
140 | 
141 |     \mu(z_i) &= z_i \\
142 |     \frac{\partial J}{\partial \beta_0} &= -\frac{1}{n}\sum_i (y_i - \mu_i) \\
143 |     \frac{\partial J}{\partial \beta_j} &= -\frac{1}{n}\sum_i (y_i - \mu_i) x_{ij}
144 |     + \lambda (1 - \alpha) \beta_j
145 | 
146 | **Hessian**
147 | 
148 | .. math::
149 | 
150 |     \frac{\partial^2 J}{\partial \beta_0^2} &= 1 \\
151 |     \frac{\partial^2 J}{\partial \beta_j^2} &=  \frac{1}{n}\sum_i x_{ij}^2
152 |     + \lambda (1 - \alpha)
153 | 
154 | Logistic: `binomial`
155 | --------------------
156 | 
157 | **Mean Function**
158 | 
159 | .. math::
160 | 
161 |     z_i &= \beta_0 + \sum_j \beta_j x_{ij} \\
162 |     \mu_i &= \frac{1}{1+\exp(-z_i)}
163 | 
164 | **Log-likelihood function**
165 | 
166 | .. math::
167 | 
168 |     \mathcal{L} = \sum_i \left\{ y_i \log(\mu_i) + (1-y_i) \log(1 - \mu_i) \right\} \\
169 | 
170 | **L2-penalized loss function**
171 | 
172 | .. math::
173 | 
174 |     J = -\frac{1}{n}\sum_i \left\{ y_i \log(\mu_i) +
175 |     (1-y_i) \log(1 - \mu_i) \right\}
176 |     + \lambda (1 - \alpha) \frac{1}{2}\sum_j \beta_j^2\\
177 | 
178 | 
179 | **Gradient**
180 | 
181 | .. math::
182 | 
183 |     \mu(z_i) &= \frac{1}{1 + \exp(-z_i)} \\
184 |     \frac{\partial J}{\partial \beta_0} &= -\frac{1}{n}\sum_i (y_i - \mu_i) \\
185 |     \frac{\partial J}{\partial \beta_j} &= -\frac{1}{n}\sum_i (y_i - \mu_i) x_{ij}
186 |     + \lambda (1 - \alpha) \beta_j
187 | 
188 | **Hessian**
189 | 
190 | .. math::
191 | 
192 |     \frac{\partial^2 J}{\partial \beta_0^2} &= \frac{1}{n}\sum_i \mu_i (1 - \mu_i) \\
193 |     \frac{\partial^2 J}{\partial \beta_j^2} &=  \frac{1}{n}\sum_i \mu_i (1 - \mu_i) x_{ij}^2
194 |     + \lambda (1 - \alpha)
195 | 
196 | Logistic: `probit`
197 | ------------------
198 | 
199 | **Mean Function**
200 | 
201 | .. math::
202 | 
203 |     z_i &= \beta_0 + \sum_j \beta_j x_{ij} \\
204 |     \mu_i &= \Phi(z_i)
205 | 
206 | where :math:`\Phi(z_i)` is the standard normal cumulative distribution function.
207 | 
208 | **Log-likelihood function**
209 | 
210 | .. math::
211 | 
212 |     \mathcal{L} = \sum_i \left\{ y_i \log(\mu_i) + (1-y_i) \log(1 - \mu_i) \right\} \\
213 | 
214 | **L2-penalized loss function**
215 | 
216 | .. math::
217 | 
218 |     J = -\frac{1}{n}\sum_i \left\{ y_i \log(\mu_i) +
219 |     (1-y_i) \log(1 - \mu_i) \right\}
220 |     + \lambda (1 - \alpha) \frac{1}{2}\sum_j \beta_j^2\\
221 | 
222 | 
223 | **Gradient**
224 | 
225 | .. math::
226 | 
227 |     \mu(z_i) &= \Phi(z_i) \\
228 |     \mu'(z_i) &= \phi(z_i)
229 | 
230 | 
231 | where :math:`\Phi(z_i)` and :math:`\phi(z_i)` are the standard normal cdf and pdf.
232 | 
233 | .. math::
234 | 
235 |     \frac{\partial J}{\partial \beta_0} &=
236 |       -\frac{1}{n}\sum_i \Bigg\{y_i \frac{\mu'(z_i)}{\mu(z_i)} - (1 - y_i)\frac{\mu'(z_i)}{1 - \mu(z_i)}\Bigg\} \\
237 |       \frac{\partial J}{\partial \beta_j} &=
238 |         -\frac{1}{n}\sum_i \Bigg\{y_i \frac{\mu'(z_i)}{\mu(z_i)} - (1 - y_i)\frac{\mu'(z_i)}{1 - \mu(z_i)}\Bigg\} x_{ij}
239 |     + \lambda (1 - \alpha) \beta_j
240 | 
241 | 
242 | **Hessian**
243 | 
244 | .. math::
245 | 
246 |     \frac{\partial^2 J}{\partial \beta_0^2} &=
247 |       \frac{1}{n}\sum_i \mu'(z_i) \Bigg\{y_i \frac{z_i\mu(z_i) + \mu'(z_i)}{\mu^2(z_i)} +
248 |       (1 - y_i)\frac{-z_i(1 - \mu(z_i)) + \mu'(z_i)}{(1 - \mu(z_i))^2} \Bigg\} \\
249 |       \frac{\partial^2 J}{\partial \beta_j^2} &=
250 |         \frac{1}{n}\sum_i \mu'(z_i) \Bigg\{y_i \frac{z_i\mu(z_i) + \mu'(z_i)}{\mu^2(z_i)} +
251 |         (1 - y_i)\frac{-z_i(1 - \mu(z_i)) + \mu'(z_i)}{(1 - \mu(z_i))^2} \Bigg\} x_{ij}^2
252 |     + \lambda (1 - \alpha)
253 | 
254 | In practice, the probit gradients suffer from instability primarily due to precision of evaluating the normal cdf.
255 | Thus, in pyglmnet we use approximate formulas for computing the loss, gradients, and hessians from `Demidenko et al. (2001)
256 | <https://pdfs.semanticscholar.org/0c03/0537919f09575b9f2c0a98c62f6571bdceee.pdf>`_.
257 | For more details, see Eqns. 17-20 in the paper.
258 | 
259 | Gamma
260 | -----
261 | 
262 | **Mean function**
263 | 
264 | .. math::
265 | 
266 |     z_i &= \beta_0 + \sum_j \beta_j x_{ij} \\
267 |     \mu_i &= \log(1 + \exp(z_i))
268 | 
269 | **Log-likelihood function**
270 | 
271 | .. math::
272 | 
273 |     \mathcal{L} = \sum_{i} \nu\Bigg\{\frac{-y_i}{\mu_i} - \log(\mu_i)\Bigg\}
274 | 
275 | where :math:`\nu` is the shape parameter. It is exponential for :math:`\nu = 1`
276 | and normal for :math:`\nu = \infty`.
277 | 
278 | **L2-penalized loss function**
279 | 
280 | .. math::
281 | 
282 |     J = -\frac{1}{n}\sum_{i} \nu\Bigg\{\frac{-y_i}{\mu_i} - \log(\mu_i)\Bigg\}
283 |     + \lambda (1 - \alpha) \frac{1}{2}\sum_j \beta_j^2\\
284 | 
285 | **Gradient**
286 | 
287 | .. math::
288 | 
289 |     \frac{\partial J}{\partial \beta_0} &= \frac{1}{n} \sum_{i} \nu\Bigg\{\frac{y_i}{\mu_i^2}
290 |     - \frac{1}{\mu_i}\Bigg\}{\mu_i'} \\
291 |     \frac{\partial J}{\partial \beta_j} &= \frac{1}{n} \sum_{i} \nu\Bigg\{\frac{y_i}{\mu_i^2}
292 |     - \frac{1}{\mu_i}\Bigg\}{\mu_i'}x_{ij} + \lambda (1 - \alpha) \beta_j
293 | 
294 | where :math:`\mu_i' = \frac{1}{1 + \exp(-z_i)}`.
295 | 
296 | 
297 | Negative Binomial
298 | -----------------
299 | **Mean Function**
300 | 
301 | .. math::
302 | 
303 |     z_i = \beta_0 + \sum_j \beta_j x_{ij} \\
304 |     \mu_i = \log(1 + \exp(z_i))
305 | 
306 | **Log-likelihood function**
307 | 
308 | .. math::
309 | 
310 |     \mathcal{L} &= \sum_{i=1}^N  \log(\Gamma(y_i+\theta))-\log(\Gamma(y_i+1))\\
311 |     &-\log(\Gamma(\theta))+\theta\log(\theta)-\log(\mu_i + \theta)(y_i+\theta))+y_i\log(\mu_i)
312 | 
313 | 
314 | **L2-penalized loss function**
315 | 
316 | .. math::
317 | 
318 |     J &= -\frac{1}{N}\sum_{i=1}^N \log(\Gamma(y_i+\theta))-\log(\Gamma(y_i+1))\\
319 |     &-\log(\Gamma(\theta))+\theta\log(\theta)-\log(\mu_i + \theta)(y_i+\theta)+y_i\log(\mu_i)\\
320 |     &+ \lambda (1 - \alpha) \frac{1}{2}\sum_j \beta_j^2\\
321 | 
322 | 
323 | **Gradient**
324 | 
325 | .. math::
326 | 
327 |     \frac{\partial J}{\partial \beta_0} &=\frac{1}{N}\sum_{i=0}^{N} \mu_i' \left( \frac{\theta + y_i}{\mu_i+\theta} -\frac{y_i}{\mu_i} \right)\\
328 |     \frac{\partial J}{\partial \beta_j} &=\frac{1}{N}\sum_{i=0}^{N} \mu_i' x_{ij} \left( \frac{\theta + y_i}{\mu_i+\theta} -\frac{y_i}{\mu_i} \right)
329 | 
330 | where :math:`\mu_i' = \frac{1}{1 + \exp(-z_i)}`.
331 | 
332 | **Hessian**
333 | 
334 | .. math::
335 | 
336 |     \frac{\partial^2 J}{\partial \beta_0^2} &= \frac{1}{N}\sum_{i=0}^{N} \mu_i'' \left( -\frac{\theta + y_i}{\theta + \mu_i} +\frac{y_i}{\mu_i} \right)
337 |     +(\mu_i')^2 \left(-\frac{y_i}{\mu_i^2} + \frac{\theta + y_i}{(\theta + \mu_i)^2} \right)\\
338 |     \frac{\partial^2 J}{\partial \beta_j^2} &= \frac{1}{N}\sum_{i=0}^{N} x_{ij}^2\mu_i'' \left( -\frac{\theta + y_i}{\theta + \mu_i} +\frac{y_i}{\mu_i} \right)
339 |     +x_{ij}^2(\mu_i')^2 \left(-\frac{y_i}{\mu_i^2} + \frac{\theta + y_i}{(\theta + \mu_i)^2} \right)
340 | 
341 | where :math:`\mu_i'' = \frac{\exp(-z_i)}{(1+\exp(-z_i))^{2}}`.
342 | 


--------------------------------------------------------------------------------
/doc/citation.rst:
--------------------------------------------------------------------------------
 1 | ========
 2 | Citation
 3 | ========
 4 | 
 5 | If you use ``pyglmnet`` package in your publication, please cite us from
 6 | our `JOSS publication <https://doi.org/10.21105/joss.01959>`__ using the following BibTex
 7 | 
 8 | .. code::
 9 | 
10 |    @article{Jas2020,
11 |    doi = {10.21105/joss.01959},
12 |    url = {https://doi.org/10.21105/joss.01959},
13 |    year = {2020},
14 |    publisher = {The Open Journal},
15 |    volume = {5},
16 |    number = {47},
17 |    pages = {1959},
18 |    author = {Mainak Jas and Titipat Achakulvisut and Aid Idrizović
19 |              and Daniel Acuna and Matthew Antalek and Vinicius Marques
20 |              and Tommy Odland and Ravi Garg and Mayank Agrawal
21 |              and Yu Umegaki and Peter Foley and Hugo Fernandes
22 |              and Drew Harris and Beibin Li and Olivier Pieters
23 |              and Scott Otterson and Giovanni De Toni and Chris Rodgers
24 |              and Eva Dyer and Matti Hamalainen and Konrad Kording and Pavan Ramkumar},
25 |    title = {{P}yglmnet: {P}ython implementation of elastic-net regularized generalized linear models},
26 |    journal = {Journal of Open Source Software}
27 |    }
28 | 
29 | or using the following string
30 | 
31 | -  Jas et al., (2020). Pyglmnet: Python implementation of elastic-net regularized
32 |    generalized linear models. Journal of Open Source Software,
33 |    5(47), 1959, https://doi.org/10.21105/joss.01959


--------------------------------------------------------------------------------
/doc/conf.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | #
  3 | # pyglmnet documentation build configuration file, created by
  4 | # sphinx-quickstart on Mon May  9 19:01:11 2016.
  5 | #
  6 | # This file is execfile()d with the current directory set to its
  7 | # containing dir.
  8 | #
  9 | # Note that not all possible configuration values are present in this
 10 | # autogenerated file.
 11 | #
 12 | # All configuration values have a default; values that are commented out
 13 | # serve to show the default.
 14 | 
 15 | import sys
 16 | import os
 17 | import sphinx
 18 | import pyglmnet
 19 | import sphinx_gallery
 20 | 
 21 | # -- General configuration ------------------------------------------------
 22 | 
 23 | # If your documentation needs a minimal Sphinx version, state it here.
 24 | #needs_sphinx = '1.0'
 25 | 
 26 | # Add any Sphinx extension module names here, as strings. They can be
 27 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 28 | # ones.
 29 | extensions = [
 30 |     'sphinx.ext.autodoc',
 31 |     'sphinx.ext.mathjax',
 32 |     'sphinx.ext.viewcode',
 33 |     'numpydoc',
 34 |     'sphinx.ext.autosummary',
 35 |     'sphinx.ext.doctest',
 36 |     'sphinx.ext.intersphinx',
 37 |     'sphinx_gallery.gen_gallery'
 38 | ]
 39 | 
 40 | # generate autosummary even if no references
 41 | autosummary_generate = True
 42 | numpydoc_show_class_members = False
 43 | 
 44 | # Add any paths that contain templates here, relative to this directory.
 45 | templates_path = ['_templates']
 46 | 
 47 | # The suffix(es) of source filenames.
 48 | # You can specify multiple suffix as a list of string:
 49 | # source_suffix = ['.rst', '.md']
 50 | source_suffix = '.rst'
 51 | 
 52 | # The encoding of source files.
 53 | #source_encoding = 'utf-8-sig'
 54 | 
 55 | # The master toctree document.
 56 | master_doc = 'index'
 57 | 
 58 | # General information about the project.
 59 | project = u'pyglmnet'
 60 | copyright = u'2016-2019, Pavan Ramkumar'
 61 | author = u'Pavan Ramkumar'
 62 | 
 63 | # The version info for the project you're documenting, acts as replacement for
 64 | # |version| and |release|, also used in various other places throughout the
 65 | # built documents.
 66 | #
 67 | # The short X.Y version.
 68 | version = pyglmnet.__version__
 69 | # The full version, including alpha/beta/rc tags.
 70 | release = pyglmnet.__version__
 71 | 
 72 | # The language for content autogenerated by Sphinx. Refer to documentation
 73 | # for a list of supported languages.
 74 | #
 75 | # This is also used if you do content translation via gettext catalogs.
 76 | # Usually you set "language" from the command line for these cases.
 77 | language = None
 78 | 
 79 | # There are two options for replacing |today|: either, you set today to some
 80 | # non-false value, then it is used:
 81 | #today = ''
 82 | # Else, today_fmt is used as the format for a strftime call.
 83 | #today_fmt = '%B %d, %Y'
 84 | 
 85 | # List of patterns, relative to source directory, that match files and
 86 | # directories to ignore when looking for source files.
 87 | exclude_patterns = ['_build']
 88 | 
 89 | # The reST default role (used for this markup: `text`) to use for all
 90 | # documents.
 91 | #default_role = None
 92 | 
 93 | # If true, '()' will be appended to :func: etc. cross-reference text.
 94 | #add_function_parentheses = True
 95 | 
 96 | # If true, the current module name will be prepended to all description
 97 | # unit titles (such as .. function::).
 98 | #add_module_names = True
 99 | 
100 | # If true, sectionauthor and moduleauthor directives will be shown in the
101 | # output. They are ignored by default.
102 | #show_authors = False
103 | 
104 | # The name of the Pygments (syntax highlighting) style to use.
105 | pygments_style = 'sphinx'
106 | 
107 | # A list of ignored prefixes for module index sorting.
108 | #modindex_common_prefix = []
109 | 
110 | # If true, keep warnings as "system message" paragraphs in the built documents.
111 | #keep_warnings = False
112 | 
113 | # If true, `todo` and `todoList` produce output, else they produce nothing.
114 | todo_include_todos = False
115 | 
116 | 
117 | # -- Options for HTML output ----------------------------------------------
118 | 
119 | # The theme to use for HTML and HTML Help pages.  See the documentation for
120 | # a list of builtin themes.
121 | html_theme = 'sphinx_rtd_theme'
122 | 
123 | # Theme options are theme-specific and customize the look and feel of a theme
124 | # further.  For a list of options available for each theme, see the
125 | # documentation.
126 | #html_theme_options = {}
127 | 
128 | # Add any paths that contain custom themes here, relative to this directory.
129 | html_theme_path = ["_themes/", ]
130 | 
131 | # The name for this set of Sphinx documents.  If None, it defaults to
132 | # "<project> v<release> documentation".
133 | #html_title = None
134 | 
135 | # A shorter title for the navigation bar.  Default is the same as html_title.
136 | #html_short_title = None
137 | 
138 | # The name of an image file (relative to this directory) to place at the top
139 | # of the sidebar.
140 | #html_logo = None
141 | 
142 | # The name of an image file (within the static path) to use as favicon of the
143 | # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
144 | # pixels large.
145 | #html_favicon = None
146 | 
147 | # Add any paths that contain custom static files (such as style sheets) here,
148 | # relative to this directory. They are copied after the builtin static files,
149 | # so a file named "default.css" will overwrite the builtin "default.css".
150 | html_static_path = ['_static']
151 | 
152 | # Add any extra paths that contain custom files (such as robots.txt or
153 | # .htaccess) here, relative to this directory. These files are copied
154 | # directly to the root of the documentation.
155 | #html_extra_path = []
156 | 
157 | # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
158 | # using the given strftime format.
159 | #html_last_updated_fmt = '%b %d, %Y'
160 | 
161 | # If true, SmartyPants will be used to convert quotes and dashes to
162 | # typographically correct entities.
163 | #html_use_smartypants = True
164 | 
165 | # Custom sidebar templates, maps document names to template names.
166 | #html_sidebars = {}
167 | 
168 | # Additional templates that should be rendered to pages, maps page names to
169 | # template names.
170 | #html_additional_pages = {}
171 | 
172 | # If false, no module index is generated.
173 | #html_domain_indices = True
174 | 
175 | # If false, no index is generated.
176 | #html_use_index = True
177 | 
178 | # If true, the index is split into individual pages for each letter.
179 | #html_split_index = False
180 | 
181 | # If true, links to the reST sources are added to the pages.
182 | #html_show_sourcelink = True
183 | 
184 | # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
185 | #html_show_sphinx = True
186 | 
187 | # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
188 | #html_show_copyright = True
189 | 
190 | # If true, an OpenSearch description file will be output, and all pages will
191 | # contain a <link> tag referring to it.  The value of this option must be the
192 | # base URL from which the finished HTML is served.
193 | #html_use_opensearch = ''
194 | 
195 | # This is the file name suffix for HTML files (e.g. ".xhtml").
196 | #html_file_suffix = None
197 | 
198 | # Language to be used for generating the HTML full-text search index.
199 | # Sphinx supports the following languages:
200 | #   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
201 | #   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
202 | #html_search_language = 'en'
203 | 
204 | # A dictionary with options for the search language support, empty by default.
205 | # Now only 'ja' uses this config value
206 | #html_search_options = {'type': 'default'}
207 | 
208 | # The name of a javascript file (relative to the configuration directory) that
209 | # implements a search results scorer. If empty, the default will be used.
210 | #html_search_scorer = 'scorer.js'
211 | 
212 | # Output file base name for HTML help builder.
213 | htmlhelp_basename = 'pyglmnetdoc'
214 | 
215 | # -- Options for LaTeX output ---------------------------------------------
216 | 
217 | latex_elements = {
218 |     # The paper size ('letterpaper' or 'a4paper').
219 |     #'papersize': 'letterpaper',
220 | 
221 |     # The font size ('10pt', '11pt' or '12pt').
222 |     #'pointsize': '10pt',
223 | 
224 |     # Additional stuff for the LaTeX preamble.
225 |     #'preamble': '',
226 | 
227 |     # Latex figure (float) alignment
228 |     #'figure_align': 'htbp',
229 | }
230 | 
231 | # Grouping the document tree into LaTeX files. List of tuples
232 | # (source start file, target name, title,
233 | #  author, documentclass [howto, manual, or own class]).
234 | latex_documents = [
235 |     (master_doc, 'pyglmnet.tex', u'pyglmnet Documentation',
236 |      u'Pavan Ramkumar', 'manual'),
237 | ]
238 | 
239 | # The name of an image file (relative to this directory) to place at the top of
240 | # the title page.
241 | #latex_logo = None
242 | 
243 | # For "manual" documents, if this is true, then toplevel headings are parts,
244 | # not chapters.
245 | #latex_use_parts = False
246 | 
247 | # If true, show page references after internal links.
248 | #latex_show_pagerefs = False
249 | 
250 | # If true, show URL addresses after external links.
251 | #latex_show_urls = False
252 | 
253 | # Documents to append as an appendix to all manuals.
254 | #latex_appendices = []
255 | 
256 | # If false, no module index is generated.
257 | #latex_domain_indices = True
258 | 
259 | 
260 | # -- Options for manual page output ---------------------------------------
261 | 
262 | # One entry per manual page. List of tuples
263 | # (source start file, name, description, authors, manual section).
264 | man_pages = [
265 |     (master_doc, 'pyglmnet', u'pyglmnet Documentation',
266 |      [author], 1)
267 | ]
268 | 
269 | # If true, show URL addresses after external links.
270 | #man_show_urls = False
271 | 
272 | 
273 | # -- Options for Texinfo output -------------------------------------------
274 | 
275 | # Grouping the document tree into Texinfo files. List of tuples
276 | # (source start file, target name, title, author,
277 | #  dir menu entry, description, category)
278 | texinfo_documents = [
279 |     (master_doc, 'pyglmnet', u'pyglmnet Documentation',
280 |      author, 'pyglmnet', 'One line description of project.',
281 |      'Miscellaneous'),
282 | ]
283 | 
284 | # Documents to append as an appendix to all manuals.
285 | #texinfo_appendices = []
286 | 
287 | # If false, no module index is generated.
288 | #texinfo_domain_indices = True
289 | 
290 | # How to display URL addresses: 'footnote', 'no', or 'inline'.
291 | #texinfo_show_urls = 'footnote'
292 | 
293 | # If true, do not generate a @detailmenu in the "Top" node's menu.
294 | #texinfo_no_detailmenu = False
295 | 
296 | intersphinx_mapping = {
297 |     'python': ('https://docs.python.org/3', None),
298 |     'numpy': ('https://numpy.org/devdocs', None),
299 |     'scipy': ('https://scipy.github.io/devdocs', None),
300 |     'matplotlib': ('https://matplotlib.org', None)
301 | }
302 | 
303 | sphinx_gallery_conf = {
304 |     'examples_dirs': '../examples',
305 |     'gallery_dirs': 'auto_examples',
306 |     'reference_url': dict(pyglmnet=None)
307 | }
308 | 


--------------------------------------------------------------------------------
/doc/contributing.rst:
--------------------------------------------------------------------------------
  1 | =======================
  2 | Developer Documentation
  3 | =======================
  4 | 
  5 | We could use help with a number of ongoing issues. If you'd like to help,
  6 | check the `issue tree <https://github.com/glm-tools/pyglmnet/issues>`_
  7 | as well as our
  8 | `requests for pull requests <https://glm-tools.github.io/pyglmnet/requests.html>`_.
  9 | 
 10 | If you've decided to make a pull request, here is an outline of the
 11 | development workflow that we have successfully adopted.
 12 | 
 13 | Setting up
 14 | ----------
 15 | 
 16 | Fork the `repository <https://github.com/glm-tools/pyglmnet>`_
 17 | to your own account (i.e. github user).
 18 | 
 19 | Clone or pull your forked repository locally. If you are doing it for the
 20 | first time:
 21 | 
 22 | .. code:: bash
 23 | 
 24 |   git clone https://github.com/<your-user-name>/pyglmnet
 25 | 
 26 | Or if you have already cloned the repository:
 27 | 
 28 | .. code:: bash
 29 | 
 30 |   git pull origin master
 31 | 
 32 | Setup a remote to point to the main upstream repository.
 33 | 
 34 | .. code:: bash
 35 | 
 36 |   git remote add upstream https://github.com/glm-tools/pyglmnet
 37 |   git remote -v
 38 | 
 39 | You should see this:
 40 | 
 41 | .. code:: console
 42 | 
 43 |   upstream	  https://github.com/glm-tools/pyglmnet.git (fetch)
 44 |   upstream	  https://github.com/glm-tools/pyglmnet.git (push)
 45 |   origin	http://github.com/<your-user-name>/pyglmnet.git (fetch)
 46 |   origin	http://github.com/<your-user-name>/pyglmnet.git (push)
 47 | 
 48 | Before you start developing a feature, make sure that your local master is
 49 | up to date. This can save you from a lot of merge conflicts later.
 50 | 
 51 | .. code:: bash
 52 | 
 53 |   git checkout master
 54 |   git pull upstream master
 55 | 
 56 | In case your own fork is behind the main repo, update your fork:
 57 | 
 58 | .. code:: bash
 59 | 
 60 |   git push origin master
 61 | 
 62 | Once you are done with these housekeeping steps, you are ready to start
 63 | developing.
 64 | 
 65 | Develop
 66 | -------
 67 | 
 68 | Make sure you develop each feature on a new branch:
 69 | 
 70 | .. code:: bash
 71 | 
 72 |   git checkout -b feat
 73 | 
 74 | Develop your changes, and once you are satisfied we need to do
 75 | a couple of things before adding and committing them.
 76 | 
 77 | First if it is a major feature, consider writing a test. You can do this by
 78 | editing ``tests/test_pyglmnet.py``.
 79 | 
 80 | Second, once you have written your tests, run them locally.
 81 | Install ``pytest`` and ``pytest-cov``:
 82 | 
 83 | .. code:: bash
 84 | 
 85 |   pip install pytest pytest-cov
 86 | 
 87 | 
 88 | .. code:: bash
 89 | 
 90 |   py.test --cov=pyglmnet tests/
 91 | 
 92 | If you don't see error messages, go ahead and test with a pep8 style checker.
 93 | We use flake8.  Install ``flake8``:
 94 | 
 95 | .. code:: bash
 96 | 
 97 |   pip install flake8
 98 |   
 99 | 
100 | .. code:: bash
101 | 
102 |   flake8 --count pyglmnet
103 | 
104 | If you don't see any errors, you are good to add and commit.
105 | 
106 | Add all the files changed and commit them with a short and meaningful message.
107 | We recommend one commit per conceptual change since it helps us keep track
108 | of what happened more easily.
109 | 
110 | Note: If you are making changes to the documentation, you will see a number
111 | of new files built when you locally build the documentation including the
112 | folders: `_build`, `auto_examples`, `generated`, `modules`, and `tutorials`.
113 | DO NOT add or commit any of these! Only add and commit the files you manually
114 | changed (typically `.rst` or `.py` files). Once a pull request is made and
115 | merged, we will build the documentation to be hosted separately (see below).
116 | 
117 | Once committed, push your local branch to a branch in your fork.
118 | 
119 | .. code:: bash
120 | 
121 |   git push origin feat:feat
122 | 
123 | Make pull request
124 | -----------------
125 | 
126 | From the ``feat`` branch of your fork: https://github.com/<your-user-name>/pyglmnet
127 | you can create a pull request on to the main repo. Give the PR a meaningful
128 | name. We recommend prefixing it with a ``[WIP]`` if the feature is being built.
129 | If you think it is ready to merge, prefix with ``[MRG]``.
130 | 
131 | If it's a complicated feature that can evolve better with feedback, we highly
132 | recommend making the PR when it's a work in progress (WIP). In the PR message box,
133 | it's typically good to associate it with an issue (e.g. "address #253")
134 | in addition to concisely describing the most salient changes made.
135 | 
136 | Once your PR is made, the tests will run. If there are errors, they will
137 | be reported on the PR's page.
138 | 
139 | Major PRs are followed by a process of peer review by one of the maintainers
140 | commenting on the code and suggesting changes.
141 | 
142 | For making changes to the PR, make changes to your local ``feat`` branch
143 | and push to your fork's ``feat`` branch just as you did before making the PR.
144 | Your new commits will be automatically associated with the PR and tested.
145 | 
146 | Sometimes you may make tiny formatting changes that are not worth retesting
147 | with our continuous integration systems. For these changes, include a ``[ci skip]``
148 | prefix in your commit message. However, use this trick sparingly!
149 | 
150 | After all suggested changes are resolved, add your name to the `whats_new`
151 | page in the appropriate section. This should be the last commit in the PR
152 | before it can be merged.
153 | 
154 | Once the PR is merged, you can optionally delete the ``feat`` branch both
155 | locally and on your fork.
156 | 
157 | Build documentation
158 | -------------------
159 | 
160 | The following should be installed in order to build the documentation.
161 | 
162 | *    `sphinx <https://github.com/sphinx-doc/sphinx/>`_
163 | *    `sphinx-gallery <https://github.com/sphinx-gallery/sphinx-gallery/>`_
164 | *    `sphinx_bootstrap_theme <https://github.com/ryan-roemer/sphinx-bootstrap-theme>`_
165 | *    `pillow <https://github.com/python-pillow/Pillow/>`_
166 | *    `numpydoc <https://github.com/numpy/numpydoc/>`_
167 | *    `matplotlib <https://github.com/matplotlib/matplotlib/>`_
168 | *    `spykes <http://kordinglab.com/spykes/>`_
169 | 
170 | Shortcut:
171 | 
172 | .. code:: bash
173 | 
174 |   pip install sphinx sphinx-gallery pillow numpydoc matplotlib
175 | 
176 | We use ``sphinx`` to generate documentation page.
177 | To build the documentation pages locally,
178 | run::
179 | 
180 |     make html
181 | 
182 | All static files will be built in ``_build/html/``
183 | where you can open them using the web browser.
184 | 
185 | To remove the built files from your local repository, run::
186 | 
187 |     make clean
188 | 
189 | To push built documentation page to ``gh-pages``, simply run::
190 | 
191 |     make install
192 | 


--------------------------------------------------------------------------------
/doc/index.rst:
--------------------------------------------------------------------------------
 1 | .. pyglmnet documentation master file, created by
 2 |    sphinx-quickstart on Mon May  23 01:07:11 2016.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | ==============================================================
 7 | Python implementation of regularized generalized linear models
 8 | ==============================================================
 9 | 
10 | Pyglmnet is a Python 3.5+ library implementing generalized linear models (GLMs)
11 | with advanced regularization options. It provides a wide range of noise models
12 | (with paired canonical link functions) including gaussian, binomial, probit,
13 | gamma, poisson, and softplus. It supports a wide range of regularizers: ridge, lasso,
14 | elastic net, group lasso, and Tikhonov regularization.
15 | 
16 | [`Repository <https://github.com/glm-tools/pyglmnet>`_]
17 | [`Documentation (stable release) <http://glm-tools.github.io/pyglmnet>`_]
18 | 
19 | A brief introduction to GLMs
20 | ============================
21 | 
22 | For linear models specified as
23 | 
24 | .. math::
25 |     y = \beta_0 + X\beta + \epsilon.
26 | 
27 | The parameters :math:`\beta_0, \beta` are estimated using ordinary least squares, under the
28 | implicit assumption that :math:`y` is normally distributed.
29 | 
30 | Generalized linear models allow us to generalize this approach to point-wise
31 | nonlinearities :math:`q(\cdot)` and corresponding exponential family noise distributions for :math:`\epsilon`.
32 | 
33 | .. math::
34 |     y = q(\beta_0 + X\beta) + \epsilon
35 | 
36 | Regularized GLMs are estimated by minimizing a loss function specified by
37 | the penalized negative log-likelihood. The elastic net penalty interpolates
38 | between the L2 and L1 norm. We solve the following optimization problem:
39 | 
40 | .. math::
41 |     \min_{\beta_0, \beta} \frac{1}{N} \sum_{i = 1}^N \mathcal{L} (y_i, \beta_0 + \beta^T x_i)
42 |     + \lambda [ \frac{1}{2}(1 - \alpha) \mathcal{P}_2 + \alpha \mathcal{P}_1 ]
43 | 
44 | where :math:`\mathcal{P}_2` and :math:`\mathcal{P}_1` are the generalized
45 | L2 (Tikhonov) and generalized L1 (Group Lasso) penalties, given by:
46 | 
47 | .. math::
48 |     \mathcal{P}_2 & = & \|\Gamma \beta \|_2^2 \\
49 |     \mathcal{P}_1 & = & \sum_g \|\beta_{j,g}\|_2
50 | 
51 | where :math:`\Gamma` is the Tikhonov matrix: a square factorization of the inverse
52 | covariance matrix and :math:`\beta_{j,g}` is the :math:`j` th coefficient of
53 | group :math:`g`.
54 | 
55 | Contents
56 | ========
57 | 
58 | .. toctree::
59 |    :maxdepth: 1
60 | 
61 |    install
62 |    start
63 |    tutorial
64 |    cheatsheet
65 |    auto_examples/index
66 |    api
67 |    contributing
68 |    resources
69 |    whats_new
70 |    citation
71 | 
72 | Questions / Errors / Bugs
73 | =========================
74 | 
75 | If you have questions about the code or find errors or bugs,
76 | please `report it here <https://github.com/glm-tools/pyglmnet/issues>`__.
77 | For more specific questions, feel free to email us directly.
78 | 


--------------------------------------------------------------------------------
/doc/install.rst:
--------------------------------------------------------------------------------
 1 | ============
 2 | Installation
 3 | ============
 4 | 
 5 | Check dependencies
 6 | ------------------
 7 | We currently support ``Python 3.5+``.
 8 | 
 9 | For the package: ``numpy>=1.11`` and ``scipy>=0.17``. For the plotting code,
10 | optionally install ``matplotlib``.
11 | 
12 | Additionally, for examples: ``pandas>=0.20`` and ``scikit-learn>=0.18``.
13 | Our library is ``scikit-learn`` compatible.
14 | 
15 | Both `Canopy <https://www.enthought.com/products/canopy/>`__
16 | and `Anaconda <https://www.continuum.io/downloads>`__
17 | ship with a recent version of all these packages.
18 | 
19 | In case you have other distributions of Python, you can install
20 | the dependencies using ``pip``.
21 | 
22 | .. code-block:: bash
23 | 
24 |    pip install numpy scipy
25 | 
26 | Get pyglmnet
27 | ------------
28 | If you would like to install the latest stable release:
29 | 
30 | .. code-block:: bash
31 | 
32 |     pip install pyglmnet
33 | 
34 | To install the development version of ``pyglmnet``, first clone the repository
35 | 
36 | .. code-block:: bash
37 | 
38 | 	pip install https://api.github.com/repos/glm-tools/pyglmnet/zipball/master
39 | 


--------------------------------------------------------------------------------
/doc/resources.rst:
--------------------------------------------------------------------------------
 1 | .. _resources:
 2 | 
 3 | Resources
 4 | =========
 5 | 
 6 | GLMs
 7 | ----
 8 | 
 9 |   1. `Generalised Linear Models`_
10 | 
11 | Sparsity book
12 | -------------
13 | 
14 |   1. `Hastie, Tibshirani, Wright. Statistical Learning with Sparsity: The Lasso and Generalizations, 2015 <http://web.stanford.edu/~hastie/StatLearnSparsity/>`_
15 | 
16 | Coordinate descent
17 | ------------------
18 | 
19 |   1. `Zou, Hastie. Regularization and Variable Selection via the Elastic Net, 2004 <https://web.stanford.edu/~hastie/Papers/elasticnet.pdf>`_
20 |   2. `S. Wright. The Revival of Coordinate Descent Methods <http://engineering.jhu.edu/ams/wp-content/uploads/sites/44/2014/08/StephenWrightSlides112014.pdf>`_
21 | 
22 | Coordinate descent applied to GLMs
23 | ----------------------------------
24 | 
25 |   1. `Gordon, Tibshirani. Coordinate descent <https://www.cs.cmu.edu/~ggordon/10725-F12/slides/25-coord-desc.pdf>`_
26 |   2. `Wu, Lange. Coordinate Descent Algorithms for LASSO Penalized Regression <http://arxiv.org/pdf/0803.3876v1.pdf>`_
27 |   3. `Friedman et. al. Pathwise coordinate optimization, 2007 <http://projecteuclid.org/download/pdfview_1/euclid.aoas/1196438020>`_
28 |   4. `Scheinberg, Tang. Practical Inexact Proximal Quasi-Newton Method with Global Complexity Analysis, 2015 <http://arxiv.org/pdf/1311.6547.pdf>`_
29 | 
30 | GAMs
31 | ----
32 | 
33 |   1. `GAM: The Predictive Modeling Silver Bullet <http://multithreaded.stitchfix.com/blog/2015/07/30/gam/>`_
34 |   2. `Fitting a Simple Additive Model in Python <http://austinrochford.com/posts/2015-08-29-additive.html>`_
35 | 
36 | Group Lasso
37 | -----------
38 | 
39 |   1. `Ivanoff et. al. Adaptive Lasso and group-Lasso for functional Poisson regression <http://jmlr.org/papers/volume17/15-021/15-021.pdf>`_
40 | 
41 | Misc
42 | ----
43 | 
44 |   1. `Candès, Wakin, Boyd. Enhancing Sparsity by Reweighted l1 Minimization <https://web.stanford.edu/~boyd/papers/pdf/rwl1.pdf>`_
45 | 
46 | .. _Generalised Linear Models: https://www.stat.tamu.edu/~suhasini/teaching613/GLM.pdf


--------------------------------------------------------------------------------
/doc/start.rst:
--------------------------------------------------------------------------------
 1 | ===============
 2 | Getting Started
 3 | ===============
 4 | 
 5 | Here is a brief example of how to use the ``GLM()`` class.
 6 | 
 7 | .. code:: python
 8 | 
 9 |     import numpy as np
10 |     import scipy.sparse as sps
11 | 
12 |     import matplotlib.pyplot as plt
13 |     from pyglmnet import GLM, simulate_glm
14 | 
15 | .. code:: python
16 | 
17 |     # number of samples, features, and distribution for GLM
18 |     n_samples, n_features = 1000, 100
19 |     distr = 'poisson'
20 | 
21 |     # sample a sparse model
22 |     np.random.seed(42)
23 |     beta0 = np.random.rand()
24 |     beta = sps.random(1, n_features, density=0.2).toarray()[0]
25 | 
26 |     # simulate data
27 |     Xtrain = np.random.normal(0.0, 1.0, [n_samples, n_features])
28 |     ytrain = simulate_glm('poisson', beta0, beta, Xtrain)
29 |     Xtest = np.random.normal(0.0, 1.0, [n_samples, n_features])
30 |     ytest = simulate_glm('poisson', beta0, beta, Xtest)
31 | 
32 | .. code:: python
33 | 
34 |     # create an instance of the GLM class
35 |     glm = GLM(distr='poisson', score_metric='pseudo_R2', reg_lambda=0.01)
36 | 
37 |     # fit the model on the training data
38 |     glm.fit(Xtrain, ytrain)
39 | 
40 |     # predict using fitted model on the test data
41 |     yhat = glm.predict(Xtest)
42 | 
43 |     # score the model on test data
44 |     pseudo_R2 = glm.score(Xtest, ytest)
45 |     print('Pseudo R^2 is %.3f' % pseudo_R2)
46 | 
47 |     # plot the true coefficients and the estimated ones
48 |     plt.stem(beta, markerfmt='r.', label='True coefficients')
49 |     plt.stem(glm.beta_, markerfmt='b.', label='Estimated coefficients')
50 |     plt.ylabel(r'$\beta$')
51 |     plt.legend(loc='upper right')
52 | 
53 |     # plot the true vs predicted label
54 |     plt.figure()
55 |     plt.plot(ytest, yhat, '.')
56 |     plt.xlabel('True labels')
57 |     plt.ylabel('Predicted labels')
58 |     plt.plot([0, ytest.max()], [0, ytest.max()], 'r--')
59 |     plt.show()
60 | 
61 | ``GLM()`` class is also designed to be compatible with ``scikit-learn``. 
62 | This means that you can apply cross-validation or perform grid search over 
63 | hyperparameters using scikit-learn's ``KFold`` or ``GridSearchCV``.
64 | 


--------------------------------------------------------------------------------
/doc/whats_new.rst:
--------------------------------------------------------------------------------
  1 | .. include:: links.inc
  2 | 
  3 | .. _whats_new:
  4 | 
  5 | .. currentmodule:: pyglmnet
  6 | 
  7 | =============
  8 | Release notes
  9 | =============
 10 | 
 11 | Current
 12 | -------
 13 | 
 14 |     - Add method :method:`pyglmnet.GLM.plot_convergence` to inspect convergence by `Mainak Jas`_.
 15 |     - Add `tqdm` to nicely visualize training time both from notebooks and command line scripts by `Giovanni De Toni`_.
 16 | 	- Add Negative Binomial distribution by `Giovanni De Toni`_, `Titipat Achakulvisut`_, `Pavan Ramkumar`_ and `Mainak Jas`_.
 17 | 
 18 | Changelog
 19 | ~~~~~~~~~
 20 | 
 21 | BUG
 22 | ~~~
 23 | 
 24 |     - Graceful handling of small Hessian term in coordinate descent solver that led to exploding update term by `Pavan Ramkumar`_.
 25 |     - Ensure full compatibility of `GLM` class with `scikit-learn` by `Titipat Achakulvisut`_.
 26 |     - Fix incorrect threshold of the proximal operator by `Yu Umegaki`_.
 27 | 
 28 | 
 29 | API
 30 | ~~~
 31 | 
 32 |     - Add fetcher for new spike train dataset :func:`pyglmnet.fetch_rgc_spike_trains` by `Titipat Achakulvisut`_.
 33 | 
 34 | .. _1_0_1:
 35 | 
 36 | Version 1.1
 37 | -----------
 38 | 
 39 | Changelog
 40 | ~~~~~~~~~
 41 | 
 42 |     - Add option for fitting `'probit'` distribution by `Ravi Garg`_.
 43 |     - Add option for fitting `'gamma'` distribution with log link by `Mainak Jas`_.
 44 |     - Add support for running :class:`sklearn.model_selection.GridSearchCV` on :class:`pyglmnet.GLM` objects by `Mainak Jas`_.
 45 |     - Improved testing of gradients for optimization by `Mainak Jas`_ and `Pavan Ramkumar`_.
 46 |     - Improved testing of estimated coefficients at convergence by `Mainak Jas`_ and `Pavan Ramkumar`_
 47 |     - Add ``n_iter_`` attribute to :class:`pyglmnet.GLM` by `Mainak Jas`_, `Olivier Pieters`_, `Peter Foley`_ and `Chris Rogers`_
 48 |     - Add option to fit intercept or not with a ``fit_intercept`` boolean by `Drew Harris`_, `Mainak Jas`_ and `Pavan Ramkumar`_
 49 | 
 50 | 
 51 | BUG
 52 | ~~~
 53 | 
 54 |     - Fixed z cache inconsistency in cdfast when ``alpha`` and ``reg_lambda`` are nonzero by `Peter Foley`_.
 55 |     - Fixed incorrect usage of the ``random_state`` parameter by `Giovanni De Toni`_.
 56 |     - Fixed incorrect proximal operator for group lasso by `Yu Umegaki`_.
 57 |     - Changed stopping criteria for convergence (a threshold on the change in objective value) which
 58 |       stopped too early. The new criteria is a threshold on the change in norm of the beta, by `Pavan Ramkumar`_.
 59 |     - Fixed ``group`` parameter not being passed for Group Lasso by `Beibin Li`_.
 60 |     - Fix URL paths when running on Windows by `Scott Otterson`_.
 61 |     - Made temporary file handling OS independent and usable on a cluster by `Scott Otterson`_.
 62 |     - Replace ``StratifiedKFold()`` with ``KFold()``, as ``StratifiedKFold()`` doesn't work for continuous values by `Scott Otterson`_.
 63 |     - :func:`pyglmnet.simulate_glm` accepts ``beta0`` as float and ``beta`` of shape `(n_features,)` only, by `Mainak Jas`_
 64 | 
 65 | API
 66 | ~~~
 67 | 
 68 |     - Refactored `GLM` class into two classes: :class:`pyglmnet.GLM` for fitting a single regularization parameter,
 69 |       and :class:`pyglmnet.GLMCV` for fitting along a regularization path with cross-validation and selection of best
 70 |       regularization parameter by `Pavan Ramkumar`_ and `Mainak Jas`_.
 71 |     - Removed support for fitting `'multinomial'` distribution by `Pavan Ramkumar`_. This option will
 72 |       be restored in a future release.
 73 | 
 74 | Authors
 75 | ~~~~~~~
 76 | 
 77 | * Beibin Li
 78 | * Chris Rodgers
 79 | * Drew Harris
 80 | * Giovanni De Toni
 81 | * Mainak Jas
 82 | * Mayank Agarawal
 83 | * Olivier Pieters
 84 | * Pavan Ramkumar
 85 | * Peter Foley
 86 | * Ravi Prakash Garg
 87 | * Scott Otterson
 88 | * Tommy Odland
 89 | * Yu Umegaki
 90 | 
 91 | .. _changes_1_0:
 92 | 
 93 | Version 1.0
 94 | -----------
 95 | 
 96 | Changelog
 97 | ~~~~~~~~~
 98 | 
 99 |     - Add GLM class by `Pavan Ramkumar`_
100 |     - Add Tikhonov regularization by `Pavan Ramkumar`_
101 |     - Add group lasso by `Eva Dyer`_
102 |     - Add group lass example by `Matt Antalek`_
103 |     - Add multinomial link function by `Daniel Acuna`_
104 |     - Add benchmarks by `Vinicius Marques`_
105 | 
106 | Authors
107 | ~~~~~~~
108 | 
109 | * Aid Idrizović
110 | * Daniel Acuna
111 | * Eva Dyer
112 | * Hugo Fernandes
113 | * Mainak Jas
114 | * Matt Antalek
115 | * Pavan Ramkumar
116 | * Titipat Achakulvisut
117 | * Vinicius Marques
118 | 
119 | .. _Aid Idrizović: https://github.com/the872
120 | .. _Daniel Acuna: https://acuna.io/
121 | .. _Eva Dyer: http://evadyer.github.io/
122 | .. _Hugo Fernandes: https://github.com/hugoguh
123 | .. _Mainak Jas: https://perso.telecom-paristech.fr/mjas/
124 | .. _Matt Antalek: https://github.com/themantalope
125 | .. _Pavan Ramkumar: https://github.com/pavanramkumar
126 | .. _Titipat Achakulvisut: https://github.com/titipata
127 | .. _Vinicius Marques: https://github.com/marquesVF
128 | .. _Ravi Garg: https://github.com/ravigarg27
129 | .. _Yu Umegaki: https://github.com/AnchorBlues
130 | .. _Giovanni De Toni: https://github.com/geektoni
131 | .. _Beibin Li: https://github.com/BeibinLi
132 | .. _Scott Otterson: https://github.com/notuntoward
133 | .. _Peter Foley: https://github.com/peterfoley
134 | .. _Olivier Pieters: https://olivierpieters.be/
135 | .. _Chris Rogers: https://github.com/cxrodgers
136 | .. _Drew Harris: https://github.com/DreHar
137 | 


--------------------------------------------------------------------------------
/examples/README.txt:
--------------------------------------------------------------------------------
1 | .. _general_examples_benchmark:
2 | 
3 | Examples Gallery
4 | ----------------
5 | 
6 | .. contents:: Contents
7 |    :local:
8 |    :depth: 2
9 | 


--------------------------------------------------------------------------------
/examples/plot_community_crime.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 | ======================
 4 | Community and Crime
 5 | ======================
 6 | 
 7 | This is a real dataset of per capita violent crime, with demographic
 8 | data comprising 128 attributes from 1994 counties in the US.
 9 | 
10 | The original dataset can be found here:
11 | http://archive.ics.uci.edu/ml/datasets/Communities+and+Crime
12 | 
13 | The target variables (per capita violent crime) are normalized to lie in
14 | a [0, 1] range. We preprocessed this dataset to exclude attributes with
15 | missing values.
16 | """
17 | 
18 | ########################################################
19 | 
20 | # Author: Vinicius Marques <vini.type@gmail.com>
21 | # License: MIT
22 | 
23 | ########################################################
24 | # Imports
25 | 
26 | import matplotlib.pyplot as plt
27 | from sklearn.model_selection import train_test_split
28 | from pyglmnet import GLM, GLMCV, datasets
29 | 
30 | ########################################################
31 | # Download and preprocess data files
32 | 
33 | X, y = datasets.fetch_community_crime_data()
34 | n_samples, n_features = X.shape
35 | 
36 | ########################################################
37 | # Split the data into training and test sets
38 | 
39 | X_train, X_test, y_train, y_test = \
40 |     train_test_split(X, y, test_size=0.33, random_state=0)
41 | 
42 | ########################################################
43 | # Fit a binomial distributed GLM with elastic net regularization
44 | 
45 | # use the default value for reg_lambda
46 | glm = GLMCV(distr='binomial', alpha=0.05, score_metric='pseudo_R2', cv=3,
47 |             tol=1e-4)
48 | 
49 | # fit model
50 | glm.fit(X_train, y_train)
51 | 
52 | # score the test set prediction
53 | y_test_hat = glm.predict_proba(X_test)
54 | print("test set pseudo $R^2$ = %f" % glm.score(X_test, y_test))
55 | 
56 | ########################################################
57 | # Now use GridSearchCV to compare
58 | 
59 | import numpy as np # noqa
60 | from sklearn.model_selection import GridSearchCV # noqa
61 | from sklearn.model_selection import KFold # noqa
62 | 
63 | cv = KFold(3)
64 | 
65 | reg_lambda = np.logspace(np.log(0.5), np.log(0.01), 10,
66 |                          base=np.exp(1))
67 | param_grid = [{'reg_lambda': reg_lambda}]
68 | 
69 | glm = GLM(distr='binomial', alpha=0.05, score_metric='pseudo_R2',
70 |           learning_rate=0.1, tol=1e-4, verbose=True)
71 | glmcv = GridSearchCV(glm, param_grid, cv=cv)
72 | glmcv.fit(X_train, y_train)
73 | 
74 | print("test set pseudo $R^2$ = %f" % glmcv.score(X_test, y_test))
75 | 
76 | ########################################################
77 | # Plot the true and predicted test set target values
78 | 
79 | plt.plot(y_test[:50], 'ko-')
80 | plt.plot(y_test_hat[:50], 'ro-')
81 | plt.legend(['true', 'pred'], frameon=False)
82 | plt.xlabel('Counties')
83 | plt.ylabel('Per capita violent crime')
84 | 
85 | plt.tick_params(axis='y', right='off')
86 | plt.tick_params(axis='x', top='off')
87 | ax = plt.gca()
88 | ax.spines['top'].set_visible(False)
89 | ax.spines['right'].set_visible(False)
90 | plt.show()
91 | 
92 | ########################################################
93 | # We can also check if the algorithm converged properly
94 | glmcv.best_estimator_.plot_convergence()
95 | 


--------------------------------------------------------------------------------
/examples/plot_glm_retinal_ganglia.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 | ================================================================
  4 | GLM for Spike Train Prediction in Primate Retinal Ganglion Cells
  5 | ================================================================
  6 | 
  7 | * Original tutorial adapted from Johnathan Pillow, Princeton University
  8 | * Dataset provided by E.J. Chichilnisky, Stanford University
  9 | * The dataset is granted by the original authors for educational use only
 10 | * Please contact ``pillow@princeton.edu`` if using beyond its purposes
 11 | 
 12 | The original MATLAB and Python tutorial can be found from
 13 | https://github.com/pillowlab/GLMspiketraintutorial.
 14 | 
 15 | These data were collected by Valerie Uzzell in the lab of
 16 | E.J. Chichilnisky at the Salk Institute. For full information see
 17 | Uzzell et al. [1]_, or Pillow et al. [2]_.
 18 | 
 19 | In this tutorial, we will demonstrate how to fit linear GLM and
 20 | Poisson GLM to predict the spike counts
 21 | recorded from primate retinal ganglion cells.
 22 | The dataset contains spike responses from 2 ON and 2 OFF parasol
 23 | retinal ganglion cells (RGCs) in primate retina, stimulated with
 24 | full-field `binary white noise`. Two experiment performed consisted of a
 25 | long (20-minute) binary stochastic (non-repeating) stimulus
 26 | which can be used for computing the spike-triggered average
 27 | (or characterizing some other model of the response).
 28 | 
 29 | References
 30 | ----------
 31 | .. [1] Uzzell, V. J., and E. J. Chichilnisky. "Precision of
 32 |    spike trains in primate retinal ganglion cells."
 33 |    Journal of Neurophysiology 92.2 (2004)
 34 | .. [2] Pillow, Jonathan W., et al. "Prediction and decoding of
 35 |    retinal ganglion cell responses with a probabilistic
 36 |    spiking model." Journal of Neuroscience 25.47 (2005)
 37 | 
 38 | """
 39 | 
 40 | # Authors: Jonathan Pillow <pillow@princeton.edu>
 41 | #          Titipat Achakulvisut <my.titipat@gmail.com>
 42 | # License: MIT
 43 | 
 44 | ########################################################
 45 | #
 46 | # Import all the relevance libraries.
 47 | 
 48 | import os.path as op
 49 | import json
 50 | 
 51 | import numpy as np
 52 | from scipy.linalg import hankel
 53 | 
 54 | from pyglmnet import GLM
 55 | from pyglmnet.datasets import fetch_rgc_spike_trains
 56 | 
 57 | import matplotlib.pyplot as plt
 58 | 
 59 | ########################################################
 60 | #
 61 | # Fetch the dataset. The JSON file contains the
 62 | # following keys:  ``stim`` (binary stochastic stimulation),
 63 | # ``stim_times`` (time of the stimulation), and
 64 | # ``spike_times`` (recorded time of the spikes)
 65 | 
 66 | dpath = fetch_rgc_spike_trains()
 67 | with open(op.join(dpath, 'data_RGCs.json'), 'r') as f:
 68 |     rgcs_dataset = json.loads(f.read())
 69 | 
 70 | stim = np.array(rgcs_dataset['stim'])
 71 | stim_times = np.array(rgcs_dataset['stim_times'])
 72 | 
 73 | n_cells = len(rgcs_dataset['spike_times'])
 74 | dt = stim_times[1] - stim_times[0]  # time between the stimulation
 75 | n_times = len(stim)  # total number of the stimulation
 76 | sfreq = 1. / dt  # frequency of the stimulation
 77 | 
 78 | ########################################################
 79 | #
 80 | # You can pick a cell to work with and visualize the spikes for one second.
 81 | # In this case, we will pick cell number 2 (ON cell).
 82 | 
 83 | cell_idx = 2  # pick cell number 2 (ON cell)
 84 | spike_times = rgcs_dataset['spike_times']['cell_%d' % cell_idx]
 85 | spike_times = np.array(spike_times)
 86 | n_spikes = len(spike_times)  # number of spikes
 87 | 
 88 | # bin the spikes to y which is our predictor
 89 | t_bins = np.arange(n_times + 1) * dt
 90 | y, _ = np.histogram(spike_times, t_bins)
 91 | 
 92 | print('Loaded RGC data: cell {}'.format(cell_idx))
 93 | print('Number of stim frames: {:d} ({:.1f} minutes)'.
 94 |       format(n_times, n_times * dt / 60))
 95 | print('Time bin size: {:.1f} ms'.format(dt * 1000))
 96 | print('Number of spikes: {} (mean rate = {:.1f} Hz)\n'.
 97 |       format(n_spikes, n_spikes / n_times * 60))
 98 | 
 99 | ########################################################
100 | #
101 | # Visualize first 120 samples
102 | sample_idx = np.arange(120)
103 | t_sample = dt * sample_idx
104 | tmax = t_sample.max()
105 | 
106 | fig, axes = plt.subplots(3, 1, sharex=True)
107 | axes[0].step(t_sample, stim[sample_idx])
108 | axes[0].set_xlim([0., tmax])
109 | axes[0].set_title('Raw Stimulus, spikes, and'
110 |                   ' spike counts')
111 | axes[0].set_ylabel('Stimulation Intensity')
112 | 
113 | tspplot = spike_times[(spike_times >= 0.) &
114 |                       (spike_times < tmax)]
115 | markerline, _, _ = axes[1].stem(spike_times[sample_idx],
116 |                                 [1] * len(spike_times[sample_idx]))
117 | markerline.set_markerfacecolor('none')
118 | axes[1].set_xlim([0., tmax])
119 | axes[1].set_ylim([0, 2])
120 | axes[1].set_ylabel('Spikes')
121 | 
122 | markerline, _, _ = axes[2].stem(t_sample, y[sample_idx])
123 | markerline.set_markerfacecolor('none')
124 | axes[2].set_xlim([0., tmax])
125 | axes[2].set_xlabel('Time (s)')
126 | axes[2].set_ylabel('Binned Spike counts')
127 | plt.show()
128 | 
129 | ########################################################
130 | #
131 | # We can use ``scipy``'s function ``hankel`` to make our design matrix.
132 | # The design matrix :math:`X` can be created using the stimulation and
133 | # its history. Later in the tutorial, we will also incorporate spikes
134 | # history into our design matrix.
135 | 
136 | n_t_filt = 25  # tweak this to see different results
137 | stim_padded = np.pad(stim, (n_t_filt - 1, 0))
138 | Xdsgn = hankel(stim_padded[0: -n_t_filt + 1], stim[-n_t_filt:])
139 | 
140 | plt.figure()
141 | plt.imshow(Xdsgn[:50, :],
142 |            cmap='binary',
143 |            aspect='auto',
144 |            interpolation='nearest')
145 | plt.xlabel('lags before spike time')
146 | plt.ylabel('time bin of response')
147 | plt.title('Sample first 50 rows of design'
148 |           ' matrix created using Hankel')
149 | plt.show()
150 | 
151 | ########################################################
152 | # **Fitting and predicting with a linear-Gaussian GLM**
153 | #
154 | # For a general linear model, the observed spikes can be
155 | # thought of an underlying parameter
156 | # :math:`\beta_0, \beta` that control the spiking.
157 | #
158 | # You can simply use linear Gaussian GLM with no regularization
159 | # to predict the spike counts.
160 | 
161 | glm_lg = GLM(distr='gaussian',
162 |              reg_lambda=0.0,
163 |              score_metric='pseudo_R2')
164 | glm_lg.fit(Xdsgn, y)
165 | 
166 | # predict spike counts
167 | ypred_lg = glm_lg.predict(Xdsgn)
168 | 
169 | ########################################################
170 | # **Fitting and predicting with a Poisson GLM**
171 | #
172 | # We can also assume that there is a non-linear function governing
173 | # the underlying the firing patterns.
174 | # In pyglmnet, we use an exponential inverse link function
175 | # for the Poisson distribution.
176 | 
177 | glm_poisson = GLM(distr='poisson',
178 |                   alpha=0.05,
179 |                   learning_rate=1.0,
180 |                   score_metric='pseudo_R2',
181 |                   reg_lambda=1e-7)
182 | glm_poisson.fit(Xdsgn, y)
183 | 
184 | # predict spike counts
185 | ypred_poisson = glm_poisson.predict(Xdsgn)
186 | 
187 | ########################################################
188 | # **Adding spikes history for predicting spike counts**
189 | #
190 | # We can even further predict the spikes by concatenating the spikes history
191 | # to the stimulation history in the design matrix.
192 | 
193 | n_t_filt = 25  # same as before, stimulation history
194 | n_t_hist = 20  # spikes history
195 | 
196 | # using both stimulation history and spikes history
197 | y_padded = np.pad(y, (n_t_hist, 0))
198 | 
199 | Xstim = hankel(stim_padded[:-n_t_filt + 1], stim[-n_t_filt:])
200 | Xspikes = hankel(y_padded[:-n_t_hist], stim[-n_t_hist:])
201 | Xdsgn_hist = np.hstack((Xstim, Xspikes))  # design matrix with spikes history
202 | 
203 | ########################################################
204 | #
205 | # .. warning::
206 | #    The spike-history portion of the design
207 | #    matrix had better be shifted so that we aren't allowed to
208 | #    use the spike count on this time bin to predict itself!
209 | #
210 | # Now, we are ready to fit Poisson GLM with spikes history.
211 | glm_poisson_hist = GLM(distr='poisson',
212 |                        alpha=0.05,
213 |                        learning_rate=1.0,
214 |                        score_metric='pseudo_R2',
215 |                        reg_lambda=1e-7)
216 | 
217 | # fit and predict with spikes history
218 | glm_poisson_hist.fit(Xdsgn_hist, y)
219 | ypred_poisson_hist = glm_poisson_hist.predict(Xdsgn_hist)
220 | 
221 | #############################################################################
222 | # **Putting all together**
223 | #
224 | # We are plotting the prediction of spike counts using
225 | # linear Gaussian GLM with offset, Poisson GLM, and
226 | # Poisson GLM with spikes history for one second.
227 | 
228 | plt.figure()
229 | markerline, _, _ = plt.stem(t_sample, y[sample_idx])
230 | markerline.set_markerfacecolor('none')
231 | plt.plot(t_sample, ypred_lg[sample_idx],
232 |          color='gold', linewidth=2, label='lgGLM with offset')
233 | plt.plot(t_sample, ypred_poisson[sample_idx],
234 |          color='green', linewidth=2, label='poissonGLM')
235 | plt.plot(t_sample, ypred_poisson_hist[sample_idx],
236 |          color='red', linewidth=2, label='poissonGLM_hist')
237 | plt.xlim([0., tmax])
238 | plt.title('Spike count prediction')
239 | plt.xlabel('Time (sec)')
240 | plt.ylabel('Binned Spike Counts')
241 | plt.legend()
242 | plt.show()
243 | 
244 | # print scores of all the fitted models
245 | print('Training perf (R^2): lin-gauss GLM, w/ offset: {:.2f}'
246 |       .format(glm_lg.score(Xdsgn, y)))
247 | print('Training perf (R^2): Pyglmnet possion GLM {:.2f}'
248 |       .format(glm_poisson.score(Xdsgn, y)))
249 | print('Training perf (R^2): Pyglmnet poisson GLM w/ spikes history {:.2f}'
250 |       .format(glm_poisson_hist.score(Xdsgn_hist, y)))
251 | 


--------------------------------------------------------------------------------
/examples/plot_group_lasso.py:
--------------------------------------------------------------------------------
 1 | """
 2 | ===========================
 3 | Group Lasso Regularization
 4 | ===========================
 5 | 
 6 | This is an example demonstrating Pyglmnet with group lasso regularization,
 7 | typical in regression problems where it is reasonable to impose penalties
 8 | to model parameters in a group-wise fashion based on domain knowledge.
 9 | 
10 | """
11 | ########################################################
12 | 
13 | # Author: Matthew Antalek <matthew.antalek@northwestern.edu>
14 | # License: MIT
15 | 
16 | ########################################################
17 | 
18 | from pyglmnet import GLMCV
19 | from pyglmnet.datasets import fetch_group_lasso_data
20 | import matplotlib.pyplot as plt
21 | 
22 | ##########################################################
23 | #
24 | # Group Lasso Example
25 | # applied to the same dataset found in:
26 | # ftp://ftp.stat.math.ethz.ch/Manuscripts/buhlmann/lukas-sara-peter.pdf
27 | #
28 | # The task here is to determine which base pairs and positions within a 7-mer
29 | # sequence are predictive of whether the sequence contains a splice
30 | # site or not.
31 | #
32 | 
33 | ##########################################################
34 | # First, we read and preprocess data
35 | X, y, group = fetch_group_lasso_data()
36 | 
37 | ##########################################################
38 | # Set up the training and testing sets
39 | 
40 | from sklearn.model_selection import train_test_split # noqa
41 | 
42 | Xtrain, Xtest, ytrain, ytest = \
43 |     train_test_split(X, y, test_size=0.2, random_state=42)
44 | 
45 | ##########################################################
46 | # Setup the models
47 | 
48 | # set up the group lasso GLM model
49 | gl_glm = GLMCV(distr="binomial", tol=1e-3,
50 |                group=group, score_metric="pseudo_R2",
51 |                alpha=1.0, learning_rate=3, max_iter=100, cv=3, verbose=True)
52 | 
53 | 
54 | # set up the lasso model
55 | glm = GLMCV(distr="binomial", tol=1e-3,
56 |             score_metric="pseudo_R2",
57 |             alpha=1.0, learning_rate=3, max_iter=100, cv=3, verbose=True)
58 | 
59 | print("gl_glm: ", gl_glm)
60 | print("glm: ", glm)
61 | 
62 | ##########################################################
63 | # Fit models
64 | 
65 | gl_glm.fit(Xtrain, ytrain)
66 | glm.fit(Xtrain, ytrain)
67 | 
68 | ##########################################################
69 | # Visualize model scores on test set
70 | 
71 | plt.figure()
72 | plt.semilogx(gl_glm.reg_lambda, gl_glm.scores_, 'go-')
73 | plt.semilogx(glm.reg_lambda, glm.scores_, 'ro--')
74 | plt.legend(['Group Lasso', 'Lasso'], frameon=False,
75 |            loc='best')
76 | plt.xlabel('$\lambda$')
77 | plt.ylabel('pseudo-$R^2$')
78 | 
79 | plt.tick_params(axis='y', right='off')
80 | plt.tick_params(axis='x', top='off')
81 | ax = plt.gca()
82 | ax.spines['top'].set_visible(False)
83 | ax.spines['right'].set_visible(False)
84 | plt.show()
85 | 


--------------------------------------------------------------------------------
/examples/plot_tikhonov.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 | ========================
  4 | Tikhonov Regularization
  5 | ========================
  6 | 
  7 | Tikhonov regularization is a generalized form of L2-regularization. It allows
  8 | us to articulate our prior knowlege about correlations between
  9 | different predictors with a multivariate Gaussian prior. Here, we demonstrate
 10 | how pyglmnet's Tikhonov regularizer can be used to estimate spatiotemporal
 11 | receptive fields (RFs) from neural data.
 12 | 
 13 | Neurons in many brain areas, including the frontal eye fields (FEF) have RFs,
 14 | defined as regions in the visual field where visual stimuli are most likely
 15 | to result in spiking activity.
 16 | 
 17 | These spatial RFs need not be static, they can vary in time in a
 18 | systematic way. We want to characterize how such spatiotemporal RFs (STRFs)
 19 | remap from one fixation to the next. Remapping is a phenomenon where
 20 | the RF of a neuron shifts to process visual information from the subsequent
 21 | fixation, prior to the onset of the saccade. The dynamics of this shift
 22 | from the "current" to the "future" RF is an active area of research.
 23 | 
 24 | With Tikhonov regularization, we can specify a prior covariance matrix
 25 | to articulate our belief that parameters encoding neighboring points
 26 | in space and time are correlated.
 27 | 
 28 | The unpublished data are courtesy of Daniel Wood and Mark Segraves,
 29 | Department of Neurobiology, Northwestern University.
 30 | """
 31 | 
 32 | ########################################################
 33 | 
 34 | # Author: Pavan Ramkumar <pavan.ramkumar@gmail.com>
 35 | # License: MIT
 36 | 
 37 | ########################################################
 38 | # Imports
 39 | 
 40 | import os.path as op
 41 | 
 42 | import numpy as np
 43 | import pandas as pd
 44 | 
 45 | from pyglmnet import GLMCV
 46 | from spykes.ml.strf import STRF
 47 | 
 48 | import matplotlib.pyplot as plt
 49 | 
 50 | ########################################################
 51 | # Download and fetch data files
 52 | 
 53 | from pyglmnet.datasets import fetch_tikhonov_data
 54 | 
 55 | dpath = fetch_tikhonov_data()
 56 | fixations_df = pd.read_csv(op.join(dpath, 'fixations.csv'))
 57 | probes_df = pd.read_csv(op.join(dpath, 'probes.csv'))
 58 | spikes_df = pd.read_csv(op.join(dpath, 'spiketimes.csv'))
 59 | spiketimes = np.squeeze(spikes_df.values)
 60 | 
 61 | ########################################################
 62 | # Design spatial basis functions
 63 | 
 64 | n_spatial_basis = 36
 65 | n_temporal_basis = 7
 66 | strf_model = STRF(patch_size=50, sigma=5,
 67 |                   n_spatial_basis=n_spatial_basis,
 68 |                   n_temporal_basis=n_temporal_basis)
 69 | spatial_basis = strf_model.make_gaussian_basis()
 70 | strf_model.visualize_gaussian_basis(spatial_basis)
 71 | 
 72 | ########################################################
 73 | # Design temporal basis functions
 74 | 
 75 | time_points = np.linspace(-100., 100., 10)
 76 | centers = [-75., -50., -25., 0, 25., 50., 75.]
 77 | temporal_basis = strf_model.make_raised_cosine_temporal_basis(
 78 |     time_points=time_points,
 79 |     centers=centers,
 80 |     widths=10. * np.ones(7))
 81 | plt.plot(time_points, temporal_basis)
 82 | plt.show()
 83 | 
 84 | ########################################################
 85 | # Design parameters
 86 | 
 87 | # Spatial extent
 88 | n_shape = 50
 89 | n_features = n_spatial_basis
 90 | 
 91 | # Window of interest
 92 | window = [-100, 100]
 93 | 
 94 | # Bin size
 95 | binsize = 20
 96 | 
 97 | # Zero pad bins
 98 | n_zero_bins = int(np.floor((window[1] - window[0]) / binsize / 2))
 99 | 
100 | ########################################################
101 | # Build design matrix
102 | 
103 | bin_template = np.arange(window[0], window[1] + binsize, binsize)
104 | n_bins = len(bin_template) - 1
105 | 
106 | probetimes = probes_df['t_probe'].values
107 | spatial_features = np.zeros((0, n_features))
108 | spike_counts = np.zeros((0,))
109 | fixation_id = np.zeros((0,))
110 | 
111 | # For each fixation
112 | for fx in fixations_df.index[:1000]:
113 | 
114 |     # Fixation time
115 |     fixation_time = fixations_df.loc[fx]['t_fix_f']
116 | 
117 |     this_fixation_spatial_features = np.zeros((n_bins, n_spatial_basis))
118 |     this_fixation_spikecounts = np.zeros(n_bins)
119 |     unique_fixation_id = fixations_df.loc[fx]['trialNum_f']
120 |     unique_fixation_id += 0.01 * fixations_df.loc[fx]['fixNum_f']
121 |     this_fixation_id = unique_fixation_id * np.ones(n_bins)
122 | 
123 |     # Look for probes in window of interest relative to fixation
124 |     probe_ids = np.searchsorted(probetimes,
125 |                                 [fixation_time + window[0] + 0.1,
126 |                                  fixation_time + window[1] - 0.1])
127 | 
128 |     # For each such probe
129 |     for probe_id in range(probe_ids[0], probe_ids[1]):
130 | 
131 |         # Check if probe lies within spatial region of interest
132 |         fix_row = fixations_df.loc[fx]['y_curFix_f']
133 |         fix_col = fixations_df.loc[fx]['x_curFix_f']
134 |         probe_row = probes_df.loc[probe_id]['y_probe']
135 |         probe_col = probes_df.loc[probe_id]['x_probe']
136 | 
137 |         if ((probe_row - fix_row) > -n_shape / 2 and
138 |             (probe_row - fix_row) < n_shape / 2 and
139 |             (probe_col - fix_col) > -n_shape / 2 and
140 |                 (probe_col - fix_col) < n_shape / 2):
141 | 
142 |             # Get probe timestamp relative to fixation
143 |             probe_time = probes_df.loc[probe_id]['t_probe']
144 |             probe_bin = np.where(bin_template < (probe_time - fixation_time))
145 |             probe_bin = probe_bin[0][-1]
146 | 
147 |             # Define an image based on the relative locations
148 |             img = np.zeros(shape=(n_shape, n_shape))
149 |             row = int(-np.round(probe_row - fix_row) + n_shape / 2 - 1)
150 |             col = int(np.round(probe_col - fix_col) + n_shape / 2 - 1)
151 |             img[row, col] = 1
152 | 
153 |             # Compute projection
154 |             basis_projection = strf_model.project_to_spatial_basis(
155 |                 img, spatial_basis)
156 |             this_fixation_spatial_features[probe_bin, :] = basis_projection
157 | 
158 |     # Count spikes in window of interest relative to fixation
159 |     bins = fixation_time + bin_template
160 |     searchsorted_idx = np.searchsorted(spiketimes,
161 |                                        [fixation_time + window[0],
162 |                                         fixation_time + window[1]])
163 |     this_fixation_spike_counts = np.histogram(
164 |         spiketimes[searchsorted_idx[0]:searchsorted_idx[1]], bins)[0]
165 | 
166 |     # Accumulate
167 |     fixation_id = np.concatenate((fixation_id, this_fixation_id), axis=0)
168 |     spatial_features = np.concatenate((spatial_features,
169 |                                        this_fixation_spatial_features), axis=0)
170 |     spike_counts = np.concatenate((spike_counts,
171 |                                    this_fixation_spike_counts), axis=0)
172 | 
173 |     # Zero pad
174 |     spatial_features = np.concatenate((
175 |         spatial_features, np.zeros((n_zero_bins, n_spatial_basis))))
176 |     fixation_id = np.concatenate((fixation_id, -999. * np.ones(n_zero_bins)))
177 | 
178 | # Convolve with temporal basis
179 | features = strf_model.convolve_with_temporal_basis(spatial_features,
180 |                                                    temporal_basis)
181 | 
182 | # Remove zeropad
183 | features = features[fixation_id != -999.]
184 | 
185 | ########################################################
186 | # Visualize the distribution of spike counts
187 | 
188 | plt.hist(spike_counts, 10)
189 | plt.show()
190 | 
191 | ########################################################
192 | # Plot a few rows of the design matrix
193 | 
194 | plt.imshow(features[30:150, :], interpolation='none')
195 | plt.show()
196 | 
197 | #################################################################
198 | # Design prior covariance matrix for Tikhonov regularization
199 | prior_cov = strf_model.design_prior_covariance(
200 |     sigma_temporal=3.,
201 |     sigma_spatial=5.)
202 | 
203 | plt.imshow(prior_cov, cmap='Greys', interpolation='none')
204 | plt.colorbar()
205 | plt.show()
206 | 
207 | np.shape(prior_cov)
208 | 
209 | ########################################################
210 | # Fit models
211 | from sklearn.model_selection import train_test_split # noqa
212 | 
213 | Xtrain, Xtest, Ytrain, Ytest = train_test_split(
214 |     features, spike_counts,
215 |     test_size=0.2,
216 |     random_state=42)
217 | 
218 | ########################################################
219 | from pyglmnet import utils # noqa
220 | 
221 | n_samples = Xtrain.shape[0]
222 | Tau = utils.tikhonov_from_prior(prior_cov, n_samples)
223 | 
224 | glm = GLMCV(distr='poisson', alpha=0., Tau=Tau, score_metric='pseudo_R2', cv=3)
225 | glm.fit(Xtrain, Ytrain)
226 | print("train score: %f" % glm.score(Xtrain, Ytrain))
227 | print("test score: %f" % glm.score(Xtest, Ytest))
228 | weights = glm.beta_
229 | 
230 | ########################################################
231 | # Visualize
232 | 
233 | for time_bin_ in range(n_temporal_basis):
234 |     RF = strf_model.make_image_from_spatial_basis(
235 |         spatial_basis,
236 |         weights[range(time_bin_, n_spatial_basis * n_temporal_basis,
237 |                       n_temporal_basis)])
238 |     plt.subplot(1, n_temporal_basis, time_bin_ + 1)
239 |     plt.imshow(RF, cmap='Blues', interpolation='none')
240 |     titletext = str(centers[time_bin_])
241 |     plt.title(titletext)
242 |     plt.axis('off')
243 | plt.show()
244 | 
245 | ########################################################
246 | 


--------------------------------------------------------------------------------
/paper/paper.bib:
--------------------------------------------------------------------------------
 1 | @article{bertran2018active,
 2 |   title={Active learning of cortical connectivity from two-photon imaging data},
 3 |   author={Bertr{\'a}n, Mart{\'\i}n A and Mart{\'\i}nez, Natalia L and Wang, Ye and Dunson, David and Sapiro, Guillermo and Ringach, Dario},
 4 |   journal={PloS one},
 5 |   volume={13},
 6 |   number={5},
 7 |   pages={e0196527},
 8 |   year={2018},
 9 |   publisher={Public Library of Science},
10 |   doi={10.1371/journal.pone.0196527}
11 | }
12 | 
13 | @article{rybakken2019decoding,
14 |   title={Decoding of neural data using cohomological feature extraction},
15 |   author={Rybakken, Erik and Baas, Nils and Dunn, Benjamin},
16 |   journal={Neural computation},
17 |   volume={31},
18 |   number={1},
19 |   pages={68--93},
20 |   year={2019},
21 |   publisher={MIT Press},
22 |   doi={10.1162/neco_a_01150}
23 | }
24 | 
25 | 
26 | @article{hofling2019probing,
27 |   title={Probing and predicting ganglion cell responses to smooth electrical stimulation in healthy and blind mouse retina},
28 |   author={H{\"o}fling, Larissa and Berens, Philipp and Zeck, G{\"u}nther},
29 |   journal={bioRxiv},
30 |   pages={609826},
31 |   year={2019},
32 |   publisher={Cold Spring Harbor Laboratory},
33 |   doi={10.1101/609826}
34 | }
35 | 
36 | @article{benjamin2017modern,
37 |   title={{Modern machine learning outperforms GLMs at predicting spikes}},
38 |   author={Benjamin, Ari S and Fernandes, Hugo L and Tomlinson, Tucker and Ramkumar, Pavan and VerSteeg, Chris and Chowdhury, Raeed and Miller, Lee and Kording, Konrad Paul},
39 |   journal={bioRxiv},
40 |   pages={111450},
41 |   year={2017},
42 |   publisher={Cold Spring Harbor Laboratory},
43 |   doi={10.1101/111450}
44 | }
45 | 
46 | @inproceedings{sklearn_api,
47 |   author    = {Lars Buitinck and Gilles Louppe and Mathieu Blondel and
48 |                Fabian Pedregosa and Andreas Mueller and Olivier Grisel and
49 |                Vlad Niculae and Peter Prettenhofer and Alexandre Gramfort
50 |                and Jaques Grobler and Robert Layton and Jake VanderPlas and
51 |                Arnaud Joly and Brian Holt and Ga{\"{e}}l Varoquaux},
52 |   title     = {{API} design for machine learning software: experiences from the scikit-learn
53 |                project},
54 |   booktitle = {ECML PKDD Workshop: Languages for Data Mining and Machine Learning},
55 |   year      = {2013},
56 |   pages = {108--122},
57 | }
58 | 
59 | @misc{Dua:2019,
60 |   author = "Dua, Dheeru and Graff, Casey",
61 |   year = "2019",
62 |   title = "{UCI} Machine Learning Repository",
63 |   url = "http://archive.ics.uci.edu/ml",
64 |   institution = "University of California, Irvine, School of Information and Computer Sciences"
65 | }
66 | 


--------------------------------------------------------------------------------
/paper/paper.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: 'Pyglmnet: Python implementation of elastic-net regularized generalized linear models'
  3 | tags:
  4 |   - Python
  5 |   - glm
  6 |   - machine-learning
  7 |   - lasso
  8 |   - elastic-net
  9 |   - group-lasso
 10 | authors:
 11 |   - name: Mainak Jas
 12 |     orcid: 0000-0002-3199-9027
 13 |     affiliation: "1, 2"
 14 |   - name: Titipat Achakulvisut
 15 |     orcid: 0000-0002-2124-2979
 16 |     affiliation: 3
 17 |   - name: Aid Idrizović
 18 |     affiliation: 4
 19 |   - name: Daniel Acuna
 20 |     affiliation: 5
 21 |   - name: Matthew Antalek
 22 |     affiliation: 6
 23 |   - name: Vinicius Marques
 24 |     affiliation: 4
 25 |   - name: Tommy Odland
 26 |     affiliation: 7
 27 |   - name: Ravi Prakash Garg
 28 |     affiliation: 6
 29 |   - name: Mayank Agrawal
 30 |     affiliation: 8
 31 |   - name: Yu Umegaki
 32 |     affiliation: 9
 33 |   - name: Peter Foley
 34 |     orcid: 0000-0002-0304-7213
 35 |     affiliation: 10
 36 |   - name: Hugo Fernandes
 37 |     orcid: 0000-0002-0168-4104
 38 |     affiliation: 11
 39 |   - name: Drew Harris
 40 |     affiliation: 12
 41 |   - name: Beibin Li
 42 |     affiliation: 13
 43 |   - name: Olivier Pieters
 44 |     orcid: 0000-0002-5473-4849
 45 |     affiliation: 14, 20
 46 |   - name: Scott Otterson
 47 |     affiliation: 15
 48 |   - name: Giovanni De Toni
 49 |     orcid: 0000-0002-8387-9983
 50 |     affiliation: 16
 51 |   - name: Chris Rodgers
 52 |     orcid: 0000-0003-1762-3450
 53 |     affiliation: 17
 54 |   - name: Eva Dyer
 55 |     affiliation: 18
 56 |   - name: Matti Hamalainen
 57 |     affiliation: "1, 2"
 58 |   - name: Konrad Kording
 59 |     affiliation: 3
 60 |   - name: Pavan Ramkumar
 61 |     orcid: 0000-0001-7450-0727
 62 |     affiliation: 19
 63 | affiliations:
 64 |  - name: Massachusetts General Hospital
 65 |    index: 1
 66 |  - name: Harvard Medical School
 67 |    index: 2
 68 |  - name: University of Pennsylvania
 69 |    index: 3
 70 |  - name: Loyola University
 71 |    index: 4
 72 |  - name: University of Syracuse
 73 |    index: 5
 74 |  - name: Northwestern University
 75 |    index: 6
 76 |  - name: Sonat Consulting
 77 |    index: 7
 78 |  - name: Princeton University
 79 |    index: 8
 80 |  - name: NTT DATA Mathematical Systems Inc
 81 |    index: 9
 82 |  - name: 605
 83 |    index: 10
 84 |  - name: Rockets of Awesome
 85 |    index: 11
 86 |  - name: Epoch Capital
 87 |    index: 12
 88 |  - name: University of Washington
 89 |    index: 13
 90 |  - name: IDLab-AIRO -- Ghent University -- imec
 91 |    index: 14
 92 |  - name: Clean Power Research
 93 |    index: 15
 94 |  - name: University of Trento
 95 |    index: 16
 96 |  - name: Columbia University
 97 |    index: 17
 98 |  - name: Georgia Tech
 99 |    index: 18
100 |  - name: System1 Biosciences Inc
101 |    index: 19
102 |  - name: Research Institute for Agriculture, Fisheries and Food
103 |    index: 20
104 | 
105 | date: 6 September 2019
106 | bibliography: paper.bib
107 | ---
108 | 
109 | # Summary
110 | 
111 | [Generalized linear models] (GLMs) are
112 | well-established tools for regression and classification and are widely
113 | applied across the sciences, economics, business, and finance.
114 | Owing to their convex loss, they are easy and efficient to fit.
115 | Moreover, they are relatively easy to interpret because of their well-defined
116 | noise distributions and point-wise nonlinearities.
117 | 
118 | Mathematically, a GLM is estimated as follows:
119 | 
120 | $$\min_{\beta_0, \beta} \frac{1}{N} \sum_{i = 1}^N \mathcal{L} (y_i, \beta_0 + \beta^T x_i)
121 | + \lambda \mathcal{P}(\beta)$$
122 | 
123 | where $\mathcal{L} (y_i, \beta_0 + \beta^T x_i)$ is the negative log-likelihood of an
124 | observation ($x_i$, $y_i$), and $\lambda \mathcal{P}(\cdot)$ is the penalty that regularizes the solution,
125 | with $\lambda$ being a hyperparameter that controls the amount of regularization.
126 | 
127 | Modern datasets can contain a number of predictor variables, and data analysis is often exploratory. To avoid overfitting of the data under these circumstances, it is critically important to regularize the model. Regularization works by adding penalty terms that penalize the model parameters in a variety of ways. It can be used to incorporate our prior knowledge about the parameters' distribution in a structured form.
128 | 
129 | Despite the attractiveness and importance of regularized GLMs, the available tools in
130 | the Python data science eco-system do not serve all common functionalities. Specifically:
131 | 
132 | - [statsmodels] provides a wide range of noise distributions but no regularization.
133 | - [scikit-learn] provides elastic net regularization but only limited noise distribution options.
134 | - [lightning] provides elastic net and group lasso regularization, but only for linear (Gaussian) and logistic (binomial) regression.
135 | 
136 | ## Pyglmnet is a response to a fragmented ecosystem
137 | 
138 | Pyglmnet offers the ability to combine different types of regularization with different GLM noise
139 | distributions. In particular, it implements a broader form of elastic net regularization that include generalized L2 and L1 penalties (Tikhonov regularization and Group Lasso, respectively) with Gaussian, Binomial, Poisson, Probit, and Gamma distributions. The table below compares pyglmnet with existing libraries as of release version 1.1.
140 | 
141 | |                    | [pyglmnet] | [scikit-learn] | [statsmodels] |   [lightning]   |   [py-glm]    | [Matlab]|   [glmnet] in R |
142 | |--------------------|:----------:|:--------------:|:-------------:|:---------------:|:-------------:|:-------:|:---------------:|
143 | | **Distributions**  |            |                |               |                 |               |         |                 |
144 | | Gaussian           |    x       |      x         |      x        |       x         |      x        |    x    |  x              |
145 | | Binomial           |    x       |      x         |      x        |       x         |      x        |    x    |  x              |
146 | | Poisson            |    x       |                |      x        |                 |      x        |    x    |  x              |
147 | | Poisson (softplus)           |    x       |                |               |                 |               |         |                 |
148 | | Probit             |    x       |                |               |                 |               |         |                 |
149 | | Gamma              |    x       |                |      x        |                 |               |    x    |                 |
150 | | **Regularization** |            |                |               |                 |               |         |                 |
151 | | L2                 |    x       |      x         |               |       x         |               |         |                 |
152 | | L1 (Lasso)              |    x       |      x         |               |       x         |               |         |  x              |
153 | | Generalized L1 (Group Lasso)        |    x       |                |               |       x         |               |         |  x              |
154 | | Generalized L2 (Tikhonov)           |    x       |                |               |                 |               |         |                 |
155 | 
156 | ## Pyglmnet is an extensible pure Python implementation
157 | 
158 | Pyglmnet implements the algorithm described in [Friedman, J., Hastie, T., & Tibshirani, R. (2010)](https://web.stanford.edu/~hastie/Papers/ESLII.pdf) and its accompanying popular R package [glmnet].
159 | As opposed to [python-glmnet] or [glmnet_python], which are wrappers around this R package, pyglmnet is written in pure Python for Python 3.5+. Therefore, it is easier to extend and more compatible with the existing data science ecosystem.
160 | 
161 | ## Pyglmnet is unit-tested and documented with examples
162 | 
163 | Pyglmnet has already been used in published work [@bertran2018active; @rybakken2019decoding; @hofling2019probing; @benjamin2017modern]. It contains unit tests and includes [documentation] in the form of tutorials, docstrings and examples that are run through continuous integration.
164 | 
165 | # Example Usage
166 | 
167 | Here, we apply pyglmnet to predict incidence of violent crime from the Community and Crime dataset, one of 400+ datasets curated by the UC Irvine Machine Learning Repository [@Dua:2019] which provides a highly curated set of 128 demographic attributes of US counties. The target variable (violent crime per capita) is normalized to the range of $[0, 1]$. Below, we demonstrate the usage of a pyglmnet's binomial-distributed GLM with elastic net regularization.
168 | 
169 | ```py
170 | from sklearn.model_selection import train_test_split
171 | from pyglmnet import GLMCV, simulate_glm, datasets
172 | 
173 | # Read dataset and split it into train/test
174 | X, y = datasets.fetch_community_crime_data()
175 | Xtrain, Xtest, ytrain, ytest = train_test_split(X, y, test_size=0.33)
176 | 
177 | # Instantiate a binomial-distributed GLM with elastic net regularization
178 | glm = GLMCV(distr='binomial', alpha=0.05, score_metric='pseudo_R2', cv=3,
179 |             tol=1e-4)
180 | 
181 | # Fit the model and then predict
182 | glm.fit(Xtrain, ytrain)
183 | yhat = glm.predict_proba(Xtest)
184 | ```
185 | 
186 | As illustrated above, pyglmnet's API is designed to be compatible with ``scikit-learn`` [@sklearn_api]. Thus, it is possible to use standard idioms such as:
187 | 
188 | ```py
189 |            glm.fit(X, y)
190 |            glm.predict(X)
191 | ```
192 | 
193 | Owing to this compatibility, tools from the ``scikit-learn`` ecosystem for building pipelines, applying cross-validation, and performing grid search over hyperparameters can also be employed with pyglmnet's estimators.
194 | 
195 | # Acknowledgements
196 | 
197 | ``Pyglmnet`` development is partly supported by NIH NINDS R01-NS104585 and the Special Research Fund (B.O.F.) of Ghent University.
198 | 
199 | # References
200 | 
201 | [Generalized linear models]: https://en.wikipedia.org/wiki/Generalized_linear_model
202 | [statsmodel]: https://www.statsmodels.org/
203 | [py-glm]: https://github.com/madrury/py-glm/
204 | [scikit-learn]: https://scikit-learn.org/stable/
205 | [statsmodels]:  http://statsmodels.sourceforge.net/devel/glm.html
206 | [lightning]: https://github.com/scikit-learn-contrib/lightning
207 | [Matlab]: https://www.mathworks.com/help/stats/glmfit.html
208 | [pyglmnet]: http://github.com/glm-tools/pyglmnet/
209 | [glmnet]: https://web.stanford.edu/~hastie/glmnet/glmnet_alpha.html
210 | [python-glmnet]: https://github.com/civisanalytics/python-glmnet
211 | [glmnet_python]: https://github.com/bbalasub1/glmnet_python
212 | [documentation]: https://glm-tools.github.io/pyglmnet/
213 | 


--------------------------------------------------------------------------------
/pyglmnet-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/pyglmnet-logo.png


--------------------------------------------------------------------------------
/pyglmnet/__init__.py:
--------------------------------------------------------------------------------
 1 | """Pyglmnet: A python implementation of elastic-net regularized generalized linear models"""
 2 | 
 3 | # PEP0440 compatible formatted version, see:
 4 | # https://www.python.org/dev/peps/pep-0440/
 5 | #
 6 | # Generic release markers:
 7 | #   X.Y
 8 | #   X.Y.Z   # For bugfix releases
 9 | #
10 | # Admissible pre-release markers:
11 | #   X.YaN   # Alpha release
12 | #   X.YbN   # Beta release
13 | #   X.YrcN  # Release Candidate
14 | #   X.Y     # Final release
15 | #
16 | # Dev branch marker is: 'X.Y.devN' where N is an integer.
17 | #
18 | 
19 | __version__ = '1.2.dev0'
20 | 
21 | 
22 | from .pyglmnet import GLM, GLMCV, _grad_L2loss, _L2loss, simulate_glm, _gradhess_logloss_1d, _loss, ALLOWED_DISTRS
23 | from .utils import softmax, label_binarizer, set_log_level
24 | from .datasets import fetch_tikhonov_data, fetch_rgc_spike_trains, fetch_community_crime_data, fetch_group_lasso_data
25 | from . import externals
26 | 


--------------------------------------------------------------------------------
/pyglmnet/base.py:
--------------------------------------------------------------------------------
  1 | """Base estimator adapted from scikit-learn."""
  2 | 
  3 | import warnings
  4 | import inspect
  5 | from distutils.version import LooseVersion
  6 | 
  7 | ##############################################################################
  8 | # adapted from scikit-learn
  9 | 
 10 | _DEFAULT_TAGS = {
 11 |     'non_deterministic': False,
 12 |     'requires_positive_X': False,
 13 |     'requires_positive_y': False,
 14 |     'X_types': ['2darray'],
 15 |     'poor_score': False,
 16 |     'no_validation': False,
 17 |     'multioutput': False,
 18 |     "allow_nan": False,
 19 |     'stateless': False,
 20 |     'multilabel': False,
 21 |     '_skip_test': False,
 22 |     '_xfail_checks': False,
 23 |     'multioutput_only': False,
 24 |     'binary_only': False,
 25 |     'requires_fit': True,
 26 |     'requires_y': False,
 27 | }
 28 | 
 29 | 
 30 | def is_classifier(estimator):
 31 |     """Return True if the given estimator is (probably) a classifier.
 32 | 
 33 |     Parameters
 34 |     ----------
 35 |     estimator : object
 36 |         Estimator object to test.
 37 |     Returns
 38 |     -------
 39 |     out : bool
 40 |         True if estimator is a classifier and False otherwise.
 41 |     """
 42 |     return getattr(estimator, "_estimator_type", None) == "classifier"
 43 | 
 44 | 
 45 | def check_version(library, min_version):
 46 |     r"""Check minimum library version required.
 47 | 
 48 |     Parameters
 49 |     ----------
 50 |     library : str
 51 |         The library name to import. Must have a ``__version__`` property.
 52 |     min_version : str
 53 |         The minimum version string. Anything that matches
 54 |         ``'(\d+ | [a-z]+ | \.)'``. Can also be empty to skip version
 55 |         check (just check for library presence).
 56 |     Returns
 57 |     -------
 58 |     ok : bool
 59 |         True if the library exists with at least the specified version.
 60 |     """
 61 |     ok = True
 62 |     try:
 63 |         library = __import__(library)
 64 |     except ImportError:
 65 |         ok = False
 66 |     else:
 67 |         if min_version:
 68 |             this_version = LooseVersion(library.__version__)
 69 |             if this_version < min_version:
 70 |                 ok = False
 71 |     return ok
 72 | 
 73 | 
 74 | class BaseEstimator(object):
 75 |     """Base class for all estimators in scikit-learn.
 76 | 
 77 |     Notes
 78 |     -----
 79 |     All estimators should specify all the parameters that can be set
 80 |     at the class level in their ``__init__`` as explicit keyword
 81 |     arguments (no ``*args`` or ``**kwargs``).
 82 |     """
 83 | 
 84 |     @classmethod
 85 |     def _get_param_names(cls):
 86 |         """Get parameter names for the estimator."""
 87 |         from inspect import signature
 88 | 
 89 |         # fetch the constructor or the original constructor before
 90 |         # deprecation wrapping if any
 91 |         init = getattr(cls.__init__, 'deprecated_original', cls.__init__)
 92 |         if init is object.__init__:
 93 |             # No explicit constructor to introspect
 94 |             return []
 95 | 
 96 |         # introspect the constructor arguments to find the model parameters
 97 |         # to represent
 98 |         init_signature = signature(init)
 99 |         # Consider the constructor parameters excluding 'self'
100 |         parameters = [p for p in init_signature.parameters.values()
101 |                       if p.name != 'self' and p.kind != p.VAR_KEYWORD]
102 |         for p in parameters:
103 |             if p.kind == p.VAR_POSITIONAL:
104 |                 raise RuntimeError("scikit-learn estimators should always "
105 |                                    "specify their parameters in the signature"
106 |                                    " of their __init__ (no varargs)."
107 |                                    " %s with constructor %s doesn't "
108 |                                    " follow this convention."
109 |                                    % (cls, init_signature))
110 |         # Extract and sort argument names excluding 'self'
111 |         return sorted([p.name for p in parameters])
112 | 
113 |     def get_params(self, deep=True):
114 |         """Get parameters for this estimator.
115 | 
116 |         Parameters
117 |         ----------
118 |         deep : boolean, optional
119 |             If True, will return the parameters for this estimator and
120 |             contained subobjects that are estimators.
121 |         Returns
122 |         -------
123 |         params : mapping of string to any
124 |             Parameter names mapped to their values.
125 |         """
126 |         out = dict()
127 |         for key in self._get_param_names():
128 |             # We need deprecation warnings to always be on in order to
129 |             # catch deprecated param values.
130 |             # This is set in utils/__init__.py but it gets overwritten
131 |             # when running under python3 somehow.
132 |             warnings.simplefilter("always", DeprecationWarning)
133 |             try:
134 |                 with warnings.catch_warnings(record=True) as w:
135 |                     value = getattr(self, key, None)
136 |                 if len(w) and w[0].category == DeprecationWarning:
137 |                     # if the parameter is deprecated, don't show it
138 |                     continue
139 |             finally:
140 |                 warnings.filters.pop(0)
141 | 
142 |             # XXX: should we rather test if instance of estimator?
143 |             if deep and hasattr(value, 'get_params'):
144 |                 deep_items = value.get_params().items()
145 |                 out.update((key + '__' + k, val) for k, val in deep_items)
146 |             out[key] = value
147 |         return out
148 | 
149 |     def set_params(self, **params):
150 |         """Set the parameters of this estimator.
151 | 
152 |         The method works on simple estimators as well as on nested objects
153 |         (such as pipelines). The latter have parameters of the form
154 |         ``<component>__<parameter>`` so that it's possible to update each
155 |         component of a nested object.
156 |         Returns
157 |         -------
158 |         self
159 |         """
160 |         if not params:
161 |             # Simple optimisation to gain speed (inspect is slow)
162 |             return self
163 |         valid_params = self.get_params(deep=True)
164 |         for key, value in params.items():
165 |             split = key.split('__', 1)
166 |             if len(split) > 1:
167 |                 # nested objects case
168 |                 name, sub_name = split
169 |                 if name not in valid_params:
170 |                     raise ValueError('Invalid parameter %s for estimator %s. '
171 |                                      'Check the list of available parameters '
172 |                                      'with `estimator.get_params().keys()`.' %
173 |                                      (name, self))
174 |                 sub_object = valid_params[name]
175 |                 sub_object.set_params(**{sub_name: value})
176 |             else:
177 |                 # simple objects case
178 |                 if key not in valid_params:
179 |                     raise ValueError('Invalid parameter %s for estimator %s. '
180 |                                      'Check the list of available parameters '
181 |                                      'with `estimator.get_params().keys()`.' %
182 |                                      (key, self.__class__.__name__))
183 |                 setattr(self, key, value)
184 |         return self
185 | 
186 |     def _get_tags(self):
187 |         collected_tags = {}
188 |         for base_class in reversed(inspect.getmro(self.__class__)):
189 |             if hasattr(base_class, '_more_tags'):
190 |                 # need the if because mixins might not have _more_tags
191 |                 # but might do redundant work in estimators
192 |                 # (i.e. calling more tags on BaseEstimator multiple times)
193 |                 more_tags = base_class._more_tags(self)
194 |                 collected_tags.update(more_tags)
195 |         return collected_tags
196 | 
197 |     def _more_tags(self):
198 |         return _DEFAULT_TAGS
199 | 
200 |     def __repr__(self):
201 |         """repr."""
202 |         from sklearn.base import _pprint
203 |         class_name = self.__class__.__name__
204 |         return '%s(%s)' % (class_name, _pprint(self.get_params(deep=False),
205 |                                                offset=len(class_name),),)
206 | 
207 |     # __getstate__ and __setstate__ are omitted because they only contain
208 |     # conditionals that are not satisfied by our objects (e.g.,
209 |     # ``if type(self).__module__.startswith('sklearn.')``.
210 | 


--------------------------------------------------------------------------------
/pyglmnet/benchmarks.py:
--------------------------------------------------------------------------------
  1 | """
  2 | A class that assists performance comparison across different software tools:
  3 | At present, we compare scikit-learn, R, statsmodels and pyglmnet
  4 | """
  5 | import time
  6 | import numpy as np
  7 | 
  8 | from pyglmnet import GLM
  9 | import statsmodels.api as sm
 10 | from sklearn.linear_model import ElasticNet, SGDClassifier
 11 | from sklearn.metrics import r2_score, accuracy_score
 12 | 
 13 | import rpy2.robjects as robjects
 14 | from rpy2.robjects.packages import importr
 15 | from rpy2.robjects import pandas2ri
 16 | pandas2ri.activate()
 17 | 
 18 | 
 19 | class BenchmarkGLM(object):
 20 |     """
 21 |     envs: list
 22 |         each entry is a string:
 23 |         one of 'sklearn', 'pyglmnet', 'R', or 'statsmodels'
 24 | 
 25 |     distr: str
 26 |         one of 'gaussian', 'binomial', 'poisson'
 27 | 
 28 |     alpha: float
 29 |         the ratio between L1 and L2 regularization in elastic net
 30 | 
 31 |     reg_lambda: float
 32 |         regularization parameter
 33 |     """
 34 | 
 35 |     def __init__(self,
 36 |                  envs=['pyglmnet', 'sklearn', 'statsmodels'],
 37 |                  distr='gaussian',
 38 |                  alpha=0.1,
 39 |                  reg_lambda=0.1,
 40 |                  n_repeats=100):
 41 |         self.envs = envs
 42 |         self.distr = distr
 43 |         self.alpha = alpha
 44 |         self.reg_lambda = reg_lambda
 45 |         self.n_repeats = n_repeats
 46 | 
 47 |     def get_benchmarks(self, X_train, y_train, X_test, y_test):
 48 |         """
 49 |         """
 50 |         n_repeats = self.n_repeats
 51 |         distr = self.distr
 52 | 
 53 |         res = dict()
 54 |         for env in self.envs:
 55 |             res[env] = dict()
 56 |             if env == 'pyglmnet':
 57 |                 # initialize model
 58 |                 model = GLM(distr=distr,
 59 |                             reg_lambda=[self.reg_lambda],
 60 |                             alpha=self.alpha,
 61 |                             solver='batch-gradient',
 62 |                             score_metric='pseudo_R2')
 63 | 
 64 |                 # fit-predict-score
 65 |                 model.fit(X_train, y_train)
 66 |                 y_test_hat = model[-1].predict(X_test)
 67 |                 y_test_hat = np.squeeze(y_test_hat)
 68 | 
 69 |                 if distr in ['gaussian', 'poisson']:
 70 |                     res[env]['score'] = \
 71 |                         r2_score(y_test, y_test_hat)
 72 |                 elif distr == 'binomial':
 73 |                     res[env]['score'] = \
 74 |                         accuracy_score(y_test,
 75 |                                        (y_test_hat > 0.5).astype(int))
 76 | 
 77 |                 # time
 78 |                 tmp = list()
 79 |                 for r in range(n_repeats):
 80 |                     start = time.time()
 81 |                     model.fit(X_train, y_train)
 82 |                     stop = time.time()
 83 |                     tmp.append(stop - start)
 84 |                 res[env]['time'] = np.min(tmp) * 1e3
 85 | 
 86 |             if env == 'sklearn':
 87 |                 if distr in ['gaussian', 'binomial']:
 88 |                     # initialize model
 89 |                     if distr == 'gaussian':
 90 |                         model = ElasticNet(alpha=self.reg_lambda,
 91 |                                            l1_ratio=self.alpha)
 92 |                     elif distr == 'binomial':
 93 | 
 94 |                         model = SGDClassifier(loss='log',
 95 |                                               penalty='elasticnet',
 96 |                                               alpha=self.reg_lambda,
 97 |                                               l1_ratio=self.alpha)
 98 | 
 99 |                     # fit-predict-score
100 |                     model.fit(X_train, y_train)
101 |                     y_test_hat = model.predict(X_test)
102 |                     res[env]['score'] = model.score(X_test, y_test)
103 | 
104 |                     # time
105 |                     tmp = list()
106 |                     for r in range(n_repeats):
107 |                         start = time.time()
108 |                         model.fit(X_train, y_train)
109 |                         stop = time.time()
110 |                         tmp.append(stop - start)
111 |                     res[env]['time'] = np.min(tmp) * 1e3
112 |                 else:
113 |                     res[env]['score'] = -999.
114 |                     res[env]['time'] = -999.
115 | 
116 |             if env == 'statsmodels':
117 |                 # initialize model
118 |                 if distr == 'gaussian':
119 |                     model = sm.GLM(y_train,
120 |                                    sm.add_constant(X_train),
121 |                                    family=sm.families.Gaussian())
122 |                 elif distr == 'binomial':
123 |                     model = sm.GLM(y_train,
124 |                                    sm.add_constant(X_train),
125 |                                    family=sm.families.Binomial())
126 |                 elif distr == 'poisson':
127 |                     model = sm.GLM(y_train,
128 |                                    sm.add_constant(X_train),
129 |                                    family=sm.families.Poisson())
130 | 
131 |                 # fit-predict-score
132 |                 statsmodels_res = model.fit()
133 |                 y_test_hat = model.predict(statsmodels_res.params,
134 |                                            exog=sm.add_constant(X_test))
135 |                 y_test_hat = np.array(y_test_hat)
136 | 
137 |                 if distr in ['gaussian', 'poisson']:
138 |                     res[env]['score'] = \
139 |                         r2_score(y_test, y_test_hat)
140 |                 elif distr == 'binomial':
141 |                     res[env]['score'] = \
142 |                         accuracy_score(y_test,
143 |                                        (y_test_hat > 0.5).astype(int))
144 | 
145 |                 # time
146 |                 tmp = list()
147 |                 for r in range(n_repeats):
148 |                     start = time.time()
149 |                     statsmodels_res = model.fit()
150 |                     stop = time.time()
151 |                     tmp.append(stop - start)
152 |                 res[env]['time'] = np.min(tmp) * 1e3
153 | 
154 |             if env == 'R':
155 |                 # initialize model
156 |                 glmnet = importr('glmnet')
157 |                 predict = robjects.r('predict')
158 | 
159 |                 # fit-predict-score
160 |                 try:
161 |                     fit = glmnet.glmnet(X_train,
162 |                                         y_train,
163 |                                         family=distr,
164 |                                         alpha=self.alpha,
165 |                                         nlambda=1)
166 |                     tmp = predict(fit, newx=X_test, s=0)
167 | 
168 |                     y_test_hat = np.zeros(y_test.shape[0])
169 |                     for i in range(y_test.shape[0]):
170 |                         y_test_hat[i] = tmp[i]
171 | 
172 |                     if distr in ['gaussian', 'poisson']:
173 |                         res[env]['score'] = \
174 |                             r2_score(y_test, y_test_hat)
175 |                     elif distr == 'binomial':
176 |                         res[env]['score'] = \
177 |                             accuracy_score(y_test,
178 |                                            (y_test_hat > 0.5).astype(int))
179 | 
180 |                     # time
181 |                     tmp = list()
182 |                     for r in range(n_repeats):
183 |                         start = time.time()
184 |                         fit = glmnet.glmnet(X_train,
185 |                                             y_train,
186 |                                             family=distr,
187 |                                             alpha=self.alpha,
188 |                                             nlambda=1)
189 |                         stop = time.time()
190 |                         tmp.append(stop - start)
191 |                     res[env]['time'] = np.min(tmp) * 1e3
192 |                 except Exception:
193 |                     res[env]['score'] = -999.
194 |                     res[env]['time'] = -999.
195 | 
196 |         return res
197 | 


--------------------------------------------------------------------------------
/pyglmnet/datasets.py:
--------------------------------------------------------------------------------
  1 | """
  2 | A set of convenience functions to download datasets for illustrative examples
  3 | """
  4 | import os
  5 | import os.path as op
  6 | import sys
  7 | import itertools
  8 | import numpy as np
  9 | from scipy.special import comb
 10 | from urllib.request import urlretrieve
 11 | 
 12 | _rgcs_license_text = """
 13 | License
 14 | -------
 15 | 
 16 | This tutorial dataset (RGC spikes data) is granted by
 17 | original authors (E.J. Chichilnisky and Jonathan Pillow).
 18 | The dataset ramains a property of the original authors.
 19 | Its use and transfer outside tutorial, e.g. for research purposes,
 20 | is prohibited without written consent to the original authors.
 21 | 
 22 | If you reference this dataset in your publications, please:
 23 |     1) acknowledge the authors: E.J. Chichilnisky and Jonathan Pillow
 24 |     2) cite the publications as indicated in the tutorial
 25 | 
 26 | If you want to use it beyond the educational
 27 | purposes or have further questions, please contact
 28 | Jonathan Pillow (pillow@princeton.edu).
 29 | """
 30 | 
 31 | 
 32 | def _reporthook(count, block_size, total_size):
 33 |     """Report download percentage."""
 34 |     # https://blog.shichao.io/2012/10/04/progress_speed_indicator_for_urlretrieve_in_python.html  # noqa
 35 | 
 36 |     if count == 0 or count * block_size >= total_size:
 37 |         print('')
 38 |     progress_size = int(count * block_size)
 39 |     percent = min(int(count * block_size * 100 / total_size), 100)
 40 |     sys.stdout.write("\r...%d%%, %d MB"
 41 |                      % (percent, progress_size / (1024 * 1024)))
 42 | 
 43 | 
 44 | def get_data_home(data_home=None):
 45 |     """Return the path of the pyglmnet data dir.
 46 | 
 47 |     Function from scikit-learn.
 48 | 
 49 |     This folder is used by some large dataset loaders to avoid downloading the
 50 |     data several times.
 51 | 
 52 |     By default the data dir is set to a folder named 'glm_data' in the
 53 |     user home folder.
 54 | 
 55 |     Parameters
 56 |     ----------
 57 |     data_home : str | None
 58 |         The path to pyglmnet data dir.
 59 |     """
 60 |     if data_home is None:
 61 |         data_home = op.join('~', 'glm_data')
 62 |     data_home = op.expanduser(data_home)
 63 |     if not op.exists(data_home):
 64 |         os.makedirs(data_home)
 65 |     return data_home
 66 | 
 67 | 
 68 | def fetch_tikhonov_data(dpath=None):
 69 |     """Downloads data for Tikhonov example.
 70 | 
 71 |     Parameters
 72 |     ----------
 73 |     dpath: str | None
 74 |         specifies path to which the data files should be downloaded.
 75 |         default: None
 76 | 
 77 |     Returns
 78 |     -------
 79 |     dpath : str
 80 |         The data path to Tikhonov dataset
 81 |     """
 82 |     dpath = get_data_home(data_home=dpath)
 83 |     fnames = ['fixations.csv', 'probes.csv', 'spiketimes.csv']
 84 | 
 85 |     if not (op.isdir(dpath) and all(op.exists(op.join(dpath, fname))
 86 |                                     for fname in fnames)):
 87 |         base_url = (
 88 |             "https://raw.githubusercontent.com/glm-tools/datasets/master"
 89 |         )
 90 |         fnames = ['fixations.csv', 'probes.csv', 'spiketimes.csv']
 91 | 
 92 |         for fname in fnames:
 93 |             url = base_url + "/tikhonov/" + fname
 94 |             fname = os.path.join(dpath, fname)
 95 |             urlretrieve(url, fname, _reporthook)
 96 | 
 97 |     return dpath
 98 | 
 99 | 
100 | def fetch_community_crime_data(dpath=None):
101 |     """Downloads community crime data.
102 | 
103 |     This function removes missing values, extracts features, and
104 |     returns numpy arrays
105 | 
106 |     Parameters
107 |     ----------
108 |     dpath: str | None
109 |         specifies path to which the data files should be downloaded.
110 |         default: None
111 | 
112 |     Returns
113 |     -------
114 |     X: numpy array
115 |         (n_samples x n_features)
116 |     y: numpy array
117 |         (n_samples,)
118 |     """
119 |     try:
120 |         import pandas as pd
121 |     except ImportError:
122 |         raise ImportError('The pandas module is required for reading the '
123 |                           'community crime dataset')
124 | 
125 |     dpath = get_data_home(data_home=dpath)
126 |     file_name = 'communities.csv'
127 | 
128 |     if not (op.isdir(dpath) and op.exists(op.join(dpath, file_name))):
129 |         fname = os.path.join(dpath, file_name)
130 |         base_url = (
131 |             "http://archive.ics.uci.edu/ml/machine-learning-databases"
132 |         )
133 |         url = base_url + "/" + "communities/communities.data"
134 | 
135 |         urlretrieve(url, fname, _reporthook)
136 | 
137 |         # Read in the file
138 |         df = pd.read_csv(fname, header=None)
139 | 
140 |     df = pd.read_csv(op.join(dpath, file_name), header=None)
141 | 
142 |     # Remove missing values
143 |     df.replace('?', np.nan, inplace=True)
144 |     df.dropna(inplace=True, axis=1)
145 |     df.dropna(inplace=True, axis=0)
146 |     df.reset_index(inplace=True, drop=True)
147 | 
148 |     # Extract predictors and target from data frame
149 |     X = np.array(df[df.keys()[range(3, 102)]])
150 |     y = np.array(df[127])
151 | 
152 |     return X, y
153 | 
154 | 
155 | def fetch_rgc_spike_trains(dpath=None, accept_rgcs_license=False):
156 |     """Downloads data for spike trains prediction in retinal ganglia cells.
157 | 
158 |     Parameters
159 |     ----------
160 |     dpath: str
161 |         specifies path to which the data files should be downloaded.
162 |         default: None
163 |     accept_rgcs_license: bool
164 |         specify to true to accept the license to use the dataset
165 |         default: False
166 | 
167 |     Returns
168 |     -------
169 |     dpath : str | None
170 |         The data path for retinal ganglia cells dataset
171 | 
172 |     Note
173 |     ----
174 |     See https://github.com/glm-tools/datasets/RGCs/ for permission
175 |     to use the dataset.
176 |     """
177 |     dpath = get_data_home(data_home=dpath)
178 |     file_name = 'data_RGCs.json'
179 | 
180 |     # if file already exist, read it from there
181 |     if not (op.isdir(dpath) and op.exists(op.join(dpath, file_name))):
182 |         # accept licence
183 |         if accept_rgcs_license:
184 |             answer = 'y'
185 |         else:
186 |             answer = input('%s\nAgree (y/[n])? ' % _rgcs_license_text)
187 |         if answer.lower() != 'y':
188 |             raise RuntimeError('You must agree to the license to use this '
189 |                                'dataset')
190 | 
191 |         base_url = (
192 |             "https://raw.githubusercontent.com/glm-tools/datasets/master"
193 |         )
194 |         fnames = ['data_RGCs.json']
195 |         for fname in fnames:
196 |             url = base_url + "/RGCs/" + fname
197 |             fname = os.path.join(dpath, fname)
198 |             urlretrieve(url, fname, _reporthook)
199 | 
200 |     return dpath
201 | 
202 | 
203 | def fetch_group_lasso_data(dpath=None):
204 |     """Downloads and formats data needed for the group lasso example.
205 | 
206 |     Parameters
207 |     ----------
208 |     dpath: str | None
209 |         specifies path to which the data files should be downloaded.
210 | 
211 |     Returns
212 |     -------
213 |     X: numpy array, shape (n_samples, n_features)
214 |         The design matrix.
215 |     y: numpy array, shape (n_samples,)
216 |         The labels.
217 |     group: list
218 |         list of group indicies, the value of the ith position in the list
219 |         is the group number for the ith regression coefficient
220 |     """
221 |     try:
222 |         import pandas as pd
223 |     except ImportError:
224 |         raise ImportError('The pandas module is required for the '
225 |                           'group lasso dataset')
226 | 
227 |     # helper functions
228 | 
229 |     def find_interaction_index(seq, subseq,
230 |                                alphabet="ATGC",
231 |                                all_possible_len_n_interactions=None):
232 |         n = len(subseq)
233 |         alphabet_interactions = \
234 |             [set(p) for
235 |              p in list(itertools.combinations_with_replacement(alphabet, n))]
236 | 
237 |         num_interactions = len(alphabet_interactions)
238 |         if all_possible_len_n_interactions is None:
239 |             all_possible_len_n_interactions = \
240 |                 [set(interaction) for
241 |                  interaction in
242 |                  list(itertools.combinations_with_replacement(seq, n))]
243 | 
244 |         subseq = set(subseq)
245 | 
246 |         group_index = num_interactions * \
247 |             all_possible_len_n_interactions.index(subseq)
248 |         value_index = alphabet_interactions.index(subseq)
249 | 
250 |         final_index = group_index + value_index
251 |         return final_index
252 | 
253 |     def create_group_indicies_list(seqlength=7,
254 |                                    alphabet="ATGC",
255 |                                    interactions=[1, 2, 3],
256 |                                    include_extra=True):
257 |         alphabet_length = len(alphabet)
258 |         index_groups = []
259 |         if include_extra:
260 |             index_groups.append(0)
261 |         group_count = 1
262 |         for inter in interactions:
263 |             n_interactions = comb(seqlength, inter)
264 |             n_alphabet_combos = comb(alphabet_length,
265 |                                      inter,
266 |                                      repetition=True)
267 | 
268 |             for x1 in range(int(n_interactions)):
269 |                 for x2 in range(int(n_alphabet_combos)):
270 |                     index_groups.append(int(group_count))
271 | 
272 |                 group_count += 1
273 |         return index_groups
274 | 
275 |     def create_feature_vector_for_sequence(seq,
276 |                                            alphabet="ATGC",
277 |                                            interactions=[1, 2, 3]):
278 |         feature_vector_length = \
279 |             sum([comb(len(seq), inter) *
280 |                  comb(len(alphabet), inter, repetition=True)
281 |                  for inter in interactions]) + 1
282 | 
283 |         feature_vector = np.zeros(int(feature_vector_length))
284 |         feature_vector[0] = 1.0
285 |         for inter in interactions:
286 |             # interactions at the current level
287 |             cur_interactions = \
288 |                 [set(p) for p in list(itertools.combinations(seq, inter))]
289 |             interaction_idxs = \
290 |                 [find_interaction_index(
291 |                  seq, cur_inter,
292 |                  all_possible_len_n_interactions=cur_interactions) + 1
293 |                  for cur_inter in cur_interactions]
294 |             feature_vector[interaction_idxs] = 1.0
295 | 
296 |         return feature_vector
297 | 
298 |     positive_url = (
299 |         "http://hollywood.mit.edu/burgelab/maxent/ssdata/MEMset/train5_hs"
300 |     )
301 |     negative_url = (
302 |         "http://hollywood.mit.edu/burgelab/maxent/ssdata/MEMset/train0_5_hs"
303 |     )
304 | 
305 |     dpath = get_data_home(data_home=dpath)
306 |     fnames = ['pos', 'neg']
307 |     if not (op.isdir(dpath) and all(op.exists(op.join(dpath, fname))
308 |                                     for fname in fnames)):
309 |         pos_file = os.path.join(dpath, 'pos')
310 |         neg_file = os.path.join(dpath, 'neg')
311 |         urlretrieve(positive_url, pos_file, _reporthook)
312 |         urlretrieve(negative_url, neg_file, _reporthook)
313 |     else:
314 |         pos_file = os.path.join(dpath, 'pos')
315 |         neg_file = os.path.join(dpath, 'neg')
316 | 
317 |     with open(pos_file) as posfp:
318 |         positive_sequences = [str(line.strip().upper()) for idx, line in
319 |                               enumerate(posfp.readlines())
320 |                               if ">" not in line and idx < 2 * 8000]
321 | 
322 |     with open(neg_file) as negfp:
323 |         negative_sequences = [str(line.strip().upper()) for idx, line in
324 |                               enumerate(negfp.readlines())
325 |                               if ">" not in line and
326 |                               idx < 2 * len(positive_sequences)]
327 | 
328 |     assert len(positive_sequences) == len(negative_sequences), \
329 |         "lengths were not the same: p={pos} n={neg}" \
330 |         .format(pos=len(positive_sequences), neg=len(negative_sequences))
331 | 
332 |     positive_vector_matrix = np.array([create_feature_vector_for_sequence(s)
333 |                                        for s in positive_sequences])
334 |     negative_vector_matrix = np.array([create_feature_vector_for_sequence(s)
335 |                                        for s in negative_sequences])
336 | 
337 |     df = pd.DataFrame(data=np.vstack((positive_vector_matrix,
338 |                                       negative_vector_matrix)))
339 |     df.loc[0:len(positive_vector_matrix), "Label"] = 1.0
340 |     df.loc[len(positive_vector_matrix):, "Label"] = 0.0
341 | 
342 |     X = df[df.columns.difference(["Label"])].values
343 |     y = df.loc[:, "Label"].values
344 |     group = create_group_indicies_list()
345 | 
346 |     return X, y, group
347 | 


--------------------------------------------------------------------------------
/pyglmnet/externals/README:
--------------------------------------------------------------------------------
1 | This directory contains bundled external dependencies that are updated
2 | every once in a while.
3 | 


--------------------------------------------------------------------------------
/pyglmnet/externals/__init__.py:
--------------------------------------------------------------------------------
1 | """
2 | External, bundled dependencies.
3 | """
4 | 


--------------------------------------------------------------------------------
/pyglmnet/externals/sklearn/__init__.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Machine learning module for Python
 3 | ==================================
 4 | sklearn is a Python module integrating classical machine
 5 | learning algorithms in the tightly-knit world of scientific Python
 6 | packages (numpy, scipy, matplotlib).
 7 | It aims to provide simple and efficient solutions to learning problems
 8 | that are accessible to everybody and reusable in various contexts:
 9 | machine-learning as a versatile tool for science and engineering.
10 | See http://scikit-learn.org for complete documentation.
11 | """
12 | 
13 | from . import utils
14 | 
15 | __all__ = ['utils']
16 | 
17 | # PEP0440 compatible formatted version, see:
18 | # https://www.python.org/dev/peps/pep-0440/
19 | #
20 | # Generic release markers:
21 | #   X.Y
22 | #   X.Y.Z   # For bugfix releases
23 | #
24 | # Admissible pre-release markers:
25 | #   X.YaN   # Alpha release
26 | #   X.YbN   # Beta release
27 | #   X.YrcN  # Release Candidate
28 | #   X.Y     # Final release
29 | #
30 | # Dev branch marker is: 'X.Y.dev' or 'X.Y.devN' where N is an integer.
31 | # 'X.Y.dev0' is the canonical version of 'X.Y.dev'
32 | #
33 | __version__ = '0.23.dev0'


--------------------------------------------------------------------------------
/pyglmnet/externals/sklearn/exceptions.py:
--------------------------------------------------------------------------------
 1 | """
 2 | The :mod:`sklearn.exceptions` module includes all custom warnings and error
 3 | classes used across scikit-learn.
 4 | """
 5 | 
 6 | __all__ = ['NotFittedError',
 7 |            'DataConversionWarning',
 8 |            'NonBLASDotWarning']
 9 | 
10 | 
11 | class NotFittedError(ValueError, AttributeError):
12 |     """Exception class to raise if estimator is used before fitting.
13 |     This class inherits from both ValueError and AttributeError to help with
14 |     exception handling and backward compatibility.
15 |     Examples
16 |     --------
17 |     >>> from sklearn.svm import LinearSVC
18 |     >>> from sklearn.exceptions import NotFittedError
19 |     >>> try:
20 |     ...     LinearSVC().predict([[1, 2], [2, 3], [3, 4]])
21 |     ... except NotFittedError as e:
22 |     ...     print(repr(e))
23 |     NotFittedError("This LinearSVC instance is not fitted yet. Call 'fit' with
24 |     appropriate arguments before using this estimator."...)
25 |     .. versionchanged:: 0.18
26 |        Moved from sklearn.utils.validation.
27 |     """
28 | 
29 | 
30 | class DataConversionWarning(UserWarning):
31 |     """Warning used to notify implicit data conversions happening in the code.
32 |     This warning occurs when some input data needs to be converted or
33 |     interpreted in a way that may not match the user's expectations.
34 |     For example, this warning may occur when the user
35 |         - passes an integer array to a function which expects float input and
36 |           will convert the input
37 |         - requests a non-copying operation, but a copy is required to meet the
38 |           implementation's data-type expectations;
39 |         - passes an input whose shape can be interpreted ambiguously.
40 |     .. versionchanged:: 0.18
41 |        Moved from sklearn.utils.validation.
42 |     """
43 | 
44 | 
45 | class EfficiencyWarning(UserWarning):
46 |     """Warning used to notify the user of inefficient computation.
47 |     This warning notifies the user that the efficiency may not be optimal due
48 |     to some reason which may be included as a part of the warning message.
49 |     This may be subclassed into a more specific Warning class.
50 |     .. versionadded:: 0.18
51 |     """
52 | 
53 | 
54 | class NonBLASDotWarning(EfficiencyWarning):
55 |     """Warning used when the dot operation does not use BLAS.
56 |     This warning is used to notify the user that BLAS was not used for dot
57 |     operation and hence the efficiency may be affected.
58 |     .. versionchanged:: 0.18
59 |        Moved from sklearn.utils.validation, extends EfficiencyWarning.
60 |     """
61 | 


--------------------------------------------------------------------------------
/pyglmnet/externals/sklearn/utils/__init__.py:
--------------------------------------------------------------------------------
1 | from .validation import (check_random_state, check_array,
2 |                          check_X_y)
3 | from .fixes import np_version
4 | from .config import get_config
5 | 
6 | __all__ = ["check_random_state", "check_array", "check_X_y"]
7 | 


--------------------------------------------------------------------------------
/pyglmnet/externals/sklearn/utils/config.py:
--------------------------------------------------------------------------------
 1 | """Global configuration state and functions for management
 2 | """
 3 | import os
 4 | 
 5 | _global_config = {
 6 |     'assume_finite': bool(os.environ.get('SKLEARN_ASSUME_FINITE', False)),
 7 |     'working_memory': int(os.environ.get('SKLEARN_WORKING_MEMORY', 1024)),
 8 |     'print_changed_only': False,
 9 | }
10 | 
11 | 
12 | def get_config():
13 |     """Retrieve current values for configuration set by :func:`set_config`
14 |     Returns
15 |     -------
16 |     config : dict
17 |         Keys are parameter names that can be passed to :func:`set_config`.
18 |     See Also
19 |     --------
20 |     config_context: Context manager for global scikit-learn configuration
21 |     set_config: Set global scikit-learn configuration
22 |     """
23 |     return _global_config.copy()
24 | 


--------------------------------------------------------------------------------
/pyglmnet/externals/sklearn/utils/extmath.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Extended math utilities.
 3 | """
 4 | # Authors: Gael Varoquaux
 5 | #          Alexandre Gramfort
 6 | #          Alexandre T. Passos
 7 | #          Olivier Grisel
 8 | #          Lars Buitinck
 9 | #          Stefan van der Walt
10 | #          Kyle Kastner
11 | #          Giorgio Patrini
12 | # License: BSD 3 clause
13 | 
14 | import numpy as np
15 | 
16 | 
17 | # Use at least float64 for the accumulating functions to avoid precision issue
18 | # see https://github.com/numpy/numpy/issues/9393. The float64 is also retained
19 | # as it is in case the float overflows
20 | def _safe_accumulator_op(op, x, *args, **kwargs):
21 |     """
22 |     This function provides numpy accumulator functions with a float64 dtype
23 |     when used on a floating point input. This prevents accumulator overflow on
24 |     smaller floating point dtypes.
25 | 
26 |     Parameters
27 |     ----------
28 |     op : function
29 |         A numpy accumulator function such as np.mean or np.sum
30 |     x : numpy array
31 |         A numpy array to apply the accumulator function
32 |     *args : positional arguments
33 |         Positional arguments passed to the accumulator function after the
34 |         input x
35 |     **kwargs : keyword arguments
36 |         Keyword arguments passed to the accumulator function
37 | 
38 |     Returns
39 |     -------
40 |     result : The output of the accumulator function passed to this function
41 |     """
42 |     if np.issubdtype(x.dtype, np.floating) and x.dtype.itemsize < 8:
43 |         result = op(x, *args, **kwargs, dtype=np.float64)
44 |     else:
45 |         result = op(x, *args, **kwargs)
46 |     return result
47 | 


--------------------------------------------------------------------------------
/pyglmnet/externals/sklearn/utils/fixes.py:
--------------------------------------------------------------------------------
 1 | """Compatibility fixes for older version of python, numpy and scipy
 2 | If you add content to this file, please give the version of the package
 3 | at which the fixe is no longer needed.
 4 | """
 5 | # Authors: Emmanuelle Gouillart <emmanuelle.gouillart@normalesup.org>
 6 | #          Gael Varoquaux <gael.varoquaux@normalesup.org>
 7 | #          Fabian Pedregosa <fpedregosa@acm.org>
 8 | #          Lars Buitinck
 9 | #
10 | # License: BSD 3 clause
11 | 
12 | import numpy as np
13 | 
14 | 
15 | def _parse_version(version_string):
16 |     version = []
17 |     for x in version_string.split('.'):
18 |         try:
19 |             version.append(int(x))
20 |         except ValueError:
21 |             # x may be of the form dev-1ea1592
22 |             version.append(x)
23 |     return tuple(version)
24 | 
25 | 
26 | np_version = _parse_version(np.__version__)
27 | 
28 | if np_version < (1, 13):
29 |     def _object_dtype_isnan(X):
30 |         return np.frompyfunc(lambda x: x != x, 1, 1)(X).astype(bool)
31 | else:
32 |     def _object_dtype_isnan(X):
33 |         return X != X
34 | 


--------------------------------------------------------------------------------
/pyglmnet/metrics.py:
--------------------------------------------------------------------------------
 1 | """ A set of scoring functions. """
 2 | 
 3 | import numpy as np
 4 | from .pyglmnet import _logL
 5 | 
 6 | 
 7 | def deviance(y, yhat, distr, theta):
 8 |     """Deviance metrics.
 9 | 
10 |     Parameters
11 |     ----------
12 |     y : array
13 |         Target labels of shape (n_samples, )
14 | 
15 |     yhat : array
16 |         Predicted labels of shape (n_samples, )
17 | 
18 |     distr: str
19 |         distribution
20 | 
21 |     Returns
22 |     -------
23 |     score : float
24 |         Deviance of the predicted labels.
25 |     """
26 |     if distr in ['softplus', 'poisson', 'neg-binomial']:
27 |         LS = _logL(distr, y, y, theta=theta)
28 |     else:
29 |         LS = 0
30 | 
31 |     L1 = _logL(distr, y, yhat, theta=theta)
32 |     score = -2 * (L1 - LS)
33 |     return score
34 | 
35 | 
36 | def pseudo_R2(X, y, yhat, ynull_, distr, theta):
37 |     """Pseudo-R2 metric.
38 | 
39 |     Parameters
40 |     ----------
41 |     y : array
42 |         Target labels of shape (n_samples, )
43 | 
44 |     yhat : array
45 |         Predicted labels of shape (n_samples, )
46 | 
47 |     ynull_ : float
48 |         Mean of the target labels (null model prediction)
49 | 
50 |     distr: str
51 |         distribution
52 | 
53 |     Returns
54 |     -------
55 |     score : float
56 |         Pseudo-R2 score.
57 |     """
58 |     if distr in ['softplus', 'poisson', 'neg-binomial']:
59 |         LS = _logL(distr, y, y, theta=theta)
60 |     else:
61 |         LS = 0
62 | 
63 |     L0 = _logL(distr, y, ynull_, theta=theta)
64 |     L1 = _logL(distr, y, yhat, theta=theta)
65 | 
66 |     if distr in ['softplus', 'poisson', 'neg-binomial']:
67 |         score = (1 - (LS - L1) / (LS - L0))
68 |     else:
69 |         score = (1 - L1 / L0)
70 |     return score
71 | 
72 | 
73 | def accuracy(y, yhat):
74 |     """Accuracy as ratio of correct predictions.
75 | 
76 |     Parameters
77 |     ----------
78 |     y : array
79 |         Target labels of shape (n_samples, )
80 | 
81 |     yhat : array
82 |         Predicted labels of shape (n_samples, )
83 | 
84 |     Returns
85 |     -------
86 |     accuracy : float
87 |         Accuracy score.
88 |     """
89 |     return float(np.sum(y == yhat)) / yhat.shape[0]
90 | 


--------------------------------------------------------------------------------
/pyglmnet/utils.py:
--------------------------------------------------------------------------------
  1 | """
  2 | A few miscellaneous helper functions for pyglmnet.py
  3 | """
  4 | 
  5 | import numpy as np
  6 | from copy import copy
  7 | import logging
  8 | from scipy.special import log1p
  9 | 
 10 | 
 11 | logger = logging.getLogger('pyglmnet')
 12 | logger.addHandler(logging.StreamHandler())
 13 | 
 14 | try:
 15 |     from tqdm.auto import tqdm
 16 |     has_tqdm = True
 17 | except ImportError:
 18 |     logger.warning(
 19 |         "tqdm library not found. Falling back to non-interactive progress "
 20 |         "visualization.")
 21 |     has_tqdm = False
 22 | 
 23 | 
 24 | def softplus(z):
 25 |     """Numerically stable version of log(1 + exp(z))."""
 26 |     # see stabilizing softplus: http://sachinashanbhag.blogspot.com/2014/05/numerically-approximation-of-log-1-expy.html # noqa
 27 |     mu = z.copy()
 28 |     mu[z > 35] = z[z > 35]
 29 |     mu[z < -10] = np.exp(z[z < -10])
 30 |     mu[(z >= -10) & (z <= 35)] = log1p(np.exp(z[(z >= -10) & (z <= 35)]))
 31 |     return mu
 32 | 
 33 | 
 34 | def softmax(w):
 35 |     """Softmax function of given array of number w.
 36 | 
 37 |     Parameters
 38 |     ----------
 39 |     w: array | list
 40 |         The array of numbers.
 41 | 
 42 |     Returns
 43 |     -------
 44 |     dist: array
 45 |         The resulting array with values ranging from 0 to 1.
 46 |     """
 47 |     w = np.array(w)
 48 |     maxes = np.amax(w, axis=1)
 49 |     maxes = maxes.reshape(maxes.shape[0], 1)
 50 |     e = np.exp(w - maxes)
 51 |     dist = e / np.sum(e, axis=1, keepdims=True)
 52 |     return dist
 53 | 
 54 | 
 55 | def label_binarizer(y):
 56 |     """Mimics scikit learn's LabelBinarizer
 57 | 
 58 | 
 59 |     Parameters
 60 |     ----------
 61 |     y: ndarray, shape (n_samples, )
 62 |         one dimensional array of class labels
 63 | 
 64 |     Returns
 65 |     -------
 66 |     yb: array, shape (n_samples, n_classes)
 67 |         one-hot encoding of labels in y
 68 |     """
 69 |     if y.ndim != 1:
 70 |         raise ValueError('y has to be one-dimensional')
 71 |     y_flat = y.ravel()
 72 |     yb = np.zeros([len(y), y.max() + 1])
 73 |     yb[np.arange(len(y)), y_flat] = 1
 74 |     return yb
 75 | 
 76 | 
 77 | def tikhonov_from_prior(prior_cov, n_samples, threshold=0.0001):
 78 |     """Given a prior covariance matrix, returns a Tikhonov matrix
 79 | 
 80 |     Parameters
 81 |     ----------
 82 |     prior_cov: array \n
 83 |         prior covariance matrix of shape (n_features x n_features)
 84 |     n_samples: int \n
 85 |         number of samples
 86 |     threshold: float \n
 87 |         ratio of largest to smallest singular value to
 88 |         approximate matrix inversion using SVD
 89 | 
 90 |     Returns
 91 |     -------
 92 |     Tau: array \n
 93 |         Tikhonov matrix of shape (n_features x n_features)
 94 |     """
 95 | 
 96 |     [U, S, V] = np.linalg.svd(prior_cov, full_matrices=False)
 97 | 
 98 |     S_ratio = S / S.max()
 99 | 
100 |     nonzero_indices = np.where(S_ratio > threshold)[0]
101 |     zero_indices = np.where(S_ratio <= threshold)[0]
102 | 
103 |     S_inv = copy(np.sqrt(S))
104 |     S_inv[zero_indices] = threshold
105 |     S_inv[nonzero_indices] = 1. / S_inv[nonzero_indices]
106 | 
107 |     Tau = np.dot(np.diag(S_inv), V)
108 |     n_features = Tau.shape[0]
109 |     Tau = 1. / n_features * Tau
110 |     return Tau
111 | 
112 | 
113 | def _check_params(distr, max_iter, fit_intercept):
114 |     from .pyglmnet import ALLOWED_DISTRS
115 | 
116 |     if distr not in ALLOWED_DISTRS:
117 |         raise ValueError('distr must be one of %s, Got '
118 |                          '%s' % (', '.join(ALLOWED_DISTRS), distr))
119 | 
120 |     if not isinstance(max_iter, int):
121 |         raise ValueError('max_iter must be of type int')
122 | 
123 |     if not isinstance(fit_intercept, bool):
124 |         raise ValueError('fit_intercept must be bool, got %s'
125 |                          % type(fit_intercept))
126 | 
127 | 
128 | def set_log_level(verbose):
129 |     """Convenience function for setting the log level.
130 | 
131 |     Parameters
132 |     ----------
133 |     verbose : bool, str, int, or None
134 |         The verbosity of messages to print. If a str, it can be either DEBUG,
135 |         INFO, WARNING, ERROR, or CRITICAL. Note that these are for
136 |         convenience and are equivalent to passing in logging.DEBUG, etc.
137 |         For bool, True is the same as 'INFO', False is the same as 'WARNING'.
138 |     """
139 |     if isinstance(verbose, bool):
140 |         if verbose is True:
141 |             verbose = 'INFO'
142 |         else:
143 |             verbose = 'WARNING'
144 |     if isinstance(verbose, str):
145 |         verbose = verbose.upper()
146 |         logging_types = dict(DEBUG=logging.DEBUG, INFO=logging.INFO,
147 |                              WARNING=logging.WARNING, ERROR=logging.ERROR,
148 |                              CRITICAL=logging.CRITICAL)
149 |         if verbose not in logging_types:
150 |             raise ValueError('verbose must be of a valid type')
151 |         verbose = logging_types[verbose]
152 |     logger.setLevel(verbose)
153 | 
154 | 
155 | def _verbose_iterable(data):
156 |     """Wrap an iterable object with tqdm.
157 | 
158 |     If tqdm is not available or if we did not set the appropriate
159 |     log level, then we fall back to the classical method.
160 | 
161 |     Parameters
162 |     ----------
163 |     data: range, list \n
164 |         This will be data which will wrapped by tqdm (if available).
165 | 
166 |     Returns
167 |     -------
168 |     wrapped_data: \n
169 |         Data object wrapped with tqdm.
170 |     """
171 |     wrapped_data = data
172 |     if logger.getEffectiveLevel() == logging.INFO:
173 |         if has_tqdm:
174 |             wrapped_data = tqdm(data, leave=False)
175 |     return wrapped_data
176 | 
177 | 
178 | def _tqdm_log(msg):
179 |     """Log a message by using either tqdm or the system logger. This method
180 |     is needed inside training loops such to provide better visualization.
181 | 
182 |     Parameters
183 |     ----------
184 |     msg: string
185 |         Message which will be printed
186 |     """
187 |     if has_tqdm:
188 |         tqdm.write(msg)
189 |     else:
190 |         logger.info(msg)
191 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | numpy>=1.11
 2 | scipy>=0.17
 3 | scikit-learn>=0.18
 4 | pandas>=0.20
 5 | pytest
 6 | pytest-cov
 7 | coverage
 8 | flake8
 9 | pydocstyle
10 | tqdm>=4.46
11 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
 1 | [nosetests]
 2 | verbosity = 2
 3 | detailed-errors = 1
 4 | with-coverage = 1
 5 | cover-package = pyglmnet
 6 | ignore-files = (benchmarks.py|datasets.py)
 7 | 
 8 | [flake8]
 9 | exclude = __init__.py,six.py,funcsigs.py
10 | ignore =
11 |   # W504: Line break occurred after a binary operator
12 |   W504,
13 |   # W605: invalid escape sequence 'x'. Conflicts with Sphinx math in docs
14 |   W605
15 | 
16 | [metadata]
17 | description-file = "README.md"
18 | url = "https://github.com/glm-tools/pyglmnet"
19 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env python
 2 | import setuptools  # noqa; we are using a setuptools namespace
 3 | from setuptools import find_packages
 4 | import os
 5 | 
 6 | 
 7 | def get_version():
 8 |     """
 9 |     Get the version without importing, so as not to invoke dependency
10 |     requirements.
11 |     """
12 |     base, _ = os.path.split(os.path.realpath(__file__))
13 |     file = os.path.join(base, "pyglmnet", "__init__.py")
14 | 
15 |     for line in open(file, "r"):
16 |         if "__version__" in line:
17 |             return line.split("=")[1].strip().strip("'").strip('"')
18 | 
19 | 
20 | descr = """Elastic-net regularized generalized linear models."""
21 | 
22 | DISTNAME = "pyglmnet"
23 | DESCRIPTION = descr
24 | MAINTAINER = "Pavan Ramkumar"
25 | MAINTAINER_EMAIL = "pavan.ramkumar@gmail.com"
26 | LICENSE = "MIT"
27 | URL = 'http://glm-tools.github.io/pyglmnet/'
28 | DOWNLOAD_URL = "https://github.com/glm-tools/pyglmnet.git"
29 | VERSION = get_version()  # Get version without importing
30 | 
31 | if __name__ == "__main__":
32 |     setuptools.setup(
33 |         name=DISTNAME,
34 |         maintainer=MAINTAINER,
35 |         maintainer_email=MAINTAINER_EMAIL,
36 |         description=DESCRIPTION,
37 |         license=LICENSE,
38 |         url=URL,
39 |         version=VERSION,
40 |         download_url=DOWNLOAD_URL,
41 |         long_description=open("README.rst").read(),
42 |         long_description_content_type='text/x-rst',
43 |         classifiers=[
44 |             "Intended Audience :: Science/Research",
45 |             "Intended Audience :: Developers",
46 |             "License :: OSI Approved",
47 |             "Programming Language :: Python",
48 |             "Topic :: Software Development",
49 |             "Topic :: Scientific/Engineering",
50 |             "Operating System :: Microsoft :: Windows",
51 |             "Operating System :: POSIX",
52 |             "Operating System :: Unix",
53 |             "Operating System :: MacOS",
54 |             "Programming Language :: Python :: 3",
55 |             "Programming Language :: Python :: 3.5",
56 |             "Programming Language :: Python :: 3.6",
57 |             "Programming Language :: Python :: 3.7",
58 |         ],
59 |         platforms="any",
60 |         packages=find_packages(),
61 |         project_urls={
62 |             'Documentation': 'http://glm-tools.github.io/pyglmnet/',
63 |             'Bug Reports': 'https://github.com/glm-tools/pyglmnet/issues',
64 |             'Source': 'https://github.com/glm-tools/pyglmnet',
65 |         },
66 |     )
67 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/glm-tools/pyglmnet/9339c5c71c908ec31cf4bebda5d9fe47dfed4f1c/tests/__init__.py


--------------------------------------------------------------------------------
/tests/test_metrics.py:
--------------------------------------------------------------------------------
 1 | """Tests for metrics."""
 2 | 
 3 | import numpy as np
 4 | from pyglmnet import GLM, simulate_glm
 5 | 
 6 | 
 7 | def test_deviance():
 8 |     """Test deviance."""
 9 |     n_samples, n_features = 1000, 100
10 | 
11 |     beta0 = np.random.rand()
12 |     beta = np.random.normal(0.0, 1.0, n_features)
13 | 
14 |     # sample train and test data
15 |     glm_sim = GLM(score_metric='deviance')
16 |     X = np.random.randn(n_samples, n_features)
17 |     y = simulate_glm(glm_sim.distr, beta0, beta, X)
18 | 
19 |     glm_sim.fit(X, y)
20 |     score = glm_sim.score(X, y)
21 | 
22 |     assert(isinstance(score, float))
23 | 
24 | 
25 | def test_pseudoR2():
26 |     """Test pseudo r2."""
27 |     n_samples, n_features = 1000, 100
28 | 
29 |     beta0 = np.random.rand()
30 |     beta = np.random.normal(0.0, 1.0, n_features)
31 | 
32 |     # sample train and test data
33 |     glm_sim = GLM(score_metric='pseudo_R2')
34 |     X = np.random.randn(n_samples, n_features)
35 |     y = simulate_glm(glm_sim.distr, beta0, beta, X)
36 | 
37 |     glm_sim.fit(X, y)
38 |     score = glm_sim.score(X, y)
39 | 
40 |     assert(isinstance(score, float))
41 | 
42 | 
43 | def test_accuracy():
44 |     """Testing accuracy."""
45 |     n_samples, n_features, n_classes = 1000, 100, 2
46 | 
47 |     beta0 = np.random.rand()
48 |     betas = np.random.normal(0.0, 1.0, (n_features, n_classes))
49 | 
50 |     # sample train and test data
51 |     glm_sim = GLM(distr='binomial', score_metric='accuracy')
52 |     X = np.random.randn(n_samples, n_features)
53 |     y = np.zeros((n_samples, 2))
54 |     for idx, beta in enumerate(betas.T):
55 |         y[:, idx] = simulate_glm(glm_sim.distr, beta0, beta, X)
56 |     y = np.argmax(y, axis=1)
57 |     glm_sim.fit(X, y)
58 |     score = glm_sim.score(X, y)
59 | 
60 |     assert(isinstance(score, float))
61 | 


--------------------------------------------------------------------------------