Showing preview only (3,890K chars total). Download the full file or copy to clipboard to get everything.
Repository: ctgk/PRML
Branch: main
Commit: b60a6853962d
Files: 184
Total size: 3.7 MB
Directory structure:
gitextract_qpn122o6/
├── .github/
│ ├── FUNDING.yml
│ └── workflows/
│ └── run-notebooks.yaml
├── .gitignore
├── .pre-commit-config.yaml
├── LICENSE
├── README.md
├── environment.yaml
├── notebooks/
│ ├── ch01_Introduction.ipynb
│ ├── ch02_Probability_Distributions.ipynb
│ ├── ch03_Linear_Models_for_Regression.ipynb
│ ├── ch04_Linear_Models_for_Classfication.ipynb
│ ├── ch05_Neural_Networks.ipynb
│ ├── ch06_Kernel_Methods.ipynb
│ ├── ch07_Sparse_Kernel_Machines.ipynb
│ ├── ch08_Graphical_Models.ipynb
│ ├── ch09_Mixture_Models_and_EM.ipynb
│ ├── ch10_Approximate_Inference.ipynb
│ ├── ch11_Sampling_Methods.ipynb
│ ├── ch12_Continuous_Latent_Variables.ipynb
│ └── ch13_Sequential_Data.ipynb
├── prml/
│ ├── __init__.py
│ ├── bayesnet/
│ │ ├── __init__.py
│ │ ├── discrete.py
│ │ ├── probability_function.py
│ │ └── random_variable.py
│ ├── clustering/
│ │ ├── __init__.py
│ │ └── k_means.py
│ ├── dimreduction/
│ │ ├── __init__.py
│ │ ├── autoencoder.py
│ │ ├── bayesian_pca.py
│ │ └── pca.py
│ ├── kernel/
│ │ ├── __init__.py
│ │ ├── gaussian_process_classifier.py
│ │ ├── gaussian_process_regressor.py
│ │ ├── kernel.py
│ │ ├── polynomial.py
│ │ ├── rbf.py
│ │ ├── relevance_vector_classifier.py
│ │ ├── relevance_vector_regressor.py
│ │ └── support_vector_classifier.py
│ ├── linear/
│ │ ├── __init__.py
│ │ ├── _bayesian_logistic_regression.py
│ │ ├── _bayesian_regression.py
│ │ ├── _classifier.py
│ │ ├── _empirical_bayes_regression.py
│ │ ├── _fishers_linear_discriminant.py
│ │ ├── _least_squares_classifier.py
│ │ ├── _linear_regression.py
│ │ ├── _logistic_regression.py
│ │ ├── _perceptron.py
│ │ ├── _regression.py
│ │ ├── _ridge_regression.py
│ │ ├── _softmax_regression.py
│ │ ├── _variational_linear_regression.py
│ │ └── _variational_logistic_regression.py
│ ├── markov/
│ │ ├── __init__.py
│ │ ├── categorical_hmm.py
│ │ ├── gaussian_hmm.py
│ │ ├── hmm.py
│ │ ├── kalman.py
│ │ ├── particle.py
│ │ └── state_space_model.py
│ ├── nn/
│ │ ├── __init__.py
│ │ ├── array/
│ │ │ ├── __init__.py
│ │ │ ├── array.py
│ │ │ ├── broadcast.py
│ │ │ ├── ones.py
│ │ │ ├── reshape.py
│ │ │ └── zeros.py
│ │ ├── config.py
│ │ ├── distribution/
│ │ │ ├── __init__.py
│ │ │ ├── bernoulli.py
│ │ │ ├── categorical.py
│ │ │ ├── distribution.py
│ │ │ └── gaussian.py
│ │ ├── function.py
│ │ ├── image/
│ │ │ ├── __init__.py
│ │ │ ├── convolve2d.py
│ │ │ ├── deconvolve2d.py
│ │ │ ├── max_pooling2d.py
│ │ │ └── util.py
│ │ ├── io/
│ │ │ ├── __init__.py
│ │ │ └── io.py
│ │ ├── loss/
│ │ │ ├── __init__.py
│ │ │ ├── kl.py
│ │ │ ├── sigmoid_cross_entropy.py
│ │ │ └── softmax_cross_entropy.py
│ │ ├── math/
│ │ │ ├── __init__.py
│ │ │ ├── add.py
│ │ │ ├── divide.py
│ │ │ ├── exp.py
│ │ │ ├── log.py
│ │ │ ├── matmul.py
│ │ │ ├── mean.py
│ │ │ ├── multiply.py
│ │ │ ├── negative.py
│ │ │ ├── power.py
│ │ │ ├── product.py
│ │ │ ├── sqrt.py
│ │ │ ├── square.py
│ │ │ ├── subtract.py
│ │ │ └── sum.py
│ │ ├── network.py
│ │ ├── nonlinear/
│ │ │ ├── __init__.py
│ │ │ ├── log_softmax.py
│ │ │ ├── logit.py
│ │ │ ├── relu.py
│ │ │ ├── sigmoid.py
│ │ │ ├── softmax.py
│ │ │ ├── softplus.py
│ │ │ └── tanh.py
│ │ ├── normalization/
│ │ │ ├── __init__.py
│ │ │ └── batch_normalization.py
│ │ ├── optimizer/
│ │ │ ├── __init__.py
│ │ │ ├── ada_delta.py
│ │ │ ├── ada_grad.py
│ │ │ ├── adam.py
│ │ │ ├── gradient.py
│ │ │ ├── momentum.py
│ │ │ ├── optimizer.py
│ │ │ └── rmsprop.py
│ │ ├── queue.py
│ │ └── random/
│ │ ├── __init__.py
│ │ ├── dropout.py
│ │ ├── normal.py
│ │ ├── random.py
│ │ └── uniform.py
│ ├── preprocess/
│ │ ├── __init__.py
│ │ ├── gaussian.py
│ │ ├── label_transformer.py
│ │ ├── polynomial.py
│ │ └── sigmoidal.py
│ ├── rv/
│ │ ├── __init__.py
│ │ ├── bernoulli.py
│ │ ├── bernoulli_mixture.py
│ │ ├── beta.py
│ │ ├── categorical.py
│ │ ├── dirichlet.py
│ │ ├── gamma.py
│ │ ├── gaussian.py
│ │ ├── multivariate_gaussian.py
│ │ ├── multivariate_gaussian_mixture.py
│ │ ├── rv.py
│ │ ├── students_t.py
│ │ ├── uniform.py
│ │ └── variational_gaussian_mixture.py
│ └── sampling/
│ ├── __init__.py
│ ├── metropolis.py
│ ├── metropolis_hastings.py
│ ├── rejection_sampling.py
│ └── sir.py
├── setup.cfg
├── setup.py
└── test/
├── __init__.py
├── test_bayesnet/
│ ├── __init__.py
│ └── test_discrete.py
├── test_linear/
│ ├── __init__.py
│ ├── test_bayesian_regression.py
│ ├── test_linear_regression.py
│ ├── test_logistic_regression.py
│ └── test_ridge_regression.py
└── test_nn/
├── __init__.py
├── test_backward.py
├── test_distribution/
│ ├── __init__.py
│ ├── test_bernoulli.py
│ └── test_gaussian.py
├── test_image/
│ ├── __init__.py
│ ├── test_convolve2d.py
│ ├── test_deconvolve2d.py
│ └── test_max_pooling2d.py
├── test_loss/
│ ├── __init__.py
│ └── test_sigmoid_cross_entropy.py
├── test_math/
│ ├── __init__.py
│ ├── test_add.py
│ ├── test_log.py
│ ├── test_matmul.py
│ ├── test_multiply.py
│ └── test_negative.py
├── test_nonlinear/
│ ├── __init__.py
│ ├── test_log_softmax.py
│ ├── test_sigmoid.py
│ ├── test_softmax.py
│ └── test_tanh.py
└── test_random/
└── __init__.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms
github: ctgk # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
================================================
FILE: .github/workflows/run-notebooks.yaml
================================================
# This workflow will install Python dependencies, run full checks defined in `.pre-commit-config.yaml` with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: Jupyter Notebooks
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main, develop ]
schedule:
# run every month on 6th day
- cron: '0 0 6 * *'
jobs:
jupyter-notebooks:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: ['3.9', '3.10', '3.11', '3.12']
steps:
- uses: actions/checkout@v2
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v2
with:
python-version: ${{ matrix.python-version }}
- name: Upgrade pip
run: python -m pip install --upgrade pip
- name: Install packages
run: pip install .[develop]
- name: Run Jupyter notebooks
run: for note in `ls notebooks/*.ipynb`; do jupyter nbconvert --to html --execute $note; if [ $? != 0 ]; then echo $note; exit 1; fi; done
================================================
FILE: .gitignore
================================================
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*,cover
.hypothesis/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# IPython Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# dotenv
.env
# virtualenv
venv/
ENV/
# Spyder project settings
.spyderproject
# Rope project settings
.ropeproject
# VSCode project settings
.vscode/
================================================
FILE: .pre-commit-config.yaml
================================================
# See https://pre-commit.com for more information
# See https://pre-commit.com/hooks.html for more hooks
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v3.2.0
hooks:
- id: trailing-whitespace
- id: end-of-file-fixer
- id: check-yaml
- id: check-added-large-files
- repo: local
hooks:
- id: assert_ascii
language: system
name: Check file encoding
entry: bash -c 'for file in "$@"; do file --mime-encoding $file | grep -q "ascii\|binary"; if [ $? != 0 ]; then echo $file; exit 1; fi; done' --
types: [text]
- id: flake8
name: Check Python format
entry: flake8 --count --show-source --statistics
language: system
types: [python]
- id: unittest
name: Run Python unittests
language: system
entry: python setup.py test
pass_filenames: false
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2018 ctgk
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# PRML
Python codes implementing algorithms described in Bishop's book "Pattern Recognition and Machine Learning"
## Required Packages
- python 3
- numpy
- scipy
- jupyter (optional: to run jupyter notebooks)
- matplotlib (optional: to plot results in the notebooks)
- sklearn (optional: to fetch data)
## Notebooks
The notebooks in this repository can be viewed with nbviewer or other tools, or you can use [Amazon SageMaker Studio Lab](https://studiolab.sagemaker.aws/), a free computing environment on AWS (prior [registration with an email address](https://studiolab.sagemaker.aws/requestAccount) is required. Please refer to [this document](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-lab-onboard.html) for usage).
From the table below, you can open the notebooks for each chapter in each of these environments.
|nbviewer|Amazon SageMaker Studio Lab|
|:-------|:--------------------------:|
|[ch1. Introduction](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch01_Introduction.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch01_Introduction.ipynb)|
|[ch2. Probability Distributions](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch02_Probability_Distributions.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch02_Probability_Distributions.ipynb)|
|[ch3. Linear Models for Regression](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch03_Linear_Models_for_Regression.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch03_Linear_Models_for_Regression.ipynb)|
|[ch4. Linear Models for Classification](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch04_Linear_Models_for_Classfication.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch04_Linear_Models_for_Classfication.ipynb)|
|[ch5. Neural Networks](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch05_Neural_Networks.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch05_Neural_Networks.ipynb)|
|[ch6. Kernel Methods](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch06_Kernel_Methods.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch06_Kernel_Methods.ipynb)|
|[ch7. Sparse Kernel Machines](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch07_Sparse_Kernel_Machines.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch07_Sparse_Kernel_Machines.ipynb)|
|[ch8. Graphical Models](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch08_Graphical_Models.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch08_Graphical_Models.ipynb)|
|[ch9. Mixture Models and EM](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch09_Mixture_Models_and_EM.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch09_Mixture_Models_and_EM.ipynb)|
|[ch10. Approximate Inference](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch10_Approximate_Inference.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch10_Approximate_Inference.ipynb)|
|[ch11. Sampling Methods](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch11_Sampling_Methods.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch11_Sampling_Methods.ipynb)|
|[ch12. Continuous Latent Variables](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch12_Continuous_Latent_Variables.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch12_Continuous_Latent_Variables.ipynb)|
|[ch13. Sequential Data](https://nbviewer.jupyter.org/github/ctgk/PRML/blob/main/notebooks/ch13_Sequential_Data.ipynb)|[](https://studiolab.sagemaker.aws/import/github/ctgk/PRML/blob/main/notebooks/ch13_Sequential_Data.ipynb)|
If you use the SageMaker Studio Lab, open a terminal and execute the following commands to install the required libraries.
```bash
conda env create -f environment.yaml # might be optional
conda activate prml
python setup.py install
```
================================================
FILE: environment.yaml
================================================
# run: conda env create -n environment.yaml
# conda activate prml
# python setup.py install
name: prml
dependencies:
- numpy
- pandas
- scipy
- scikit-learn
- matplotlib
- ipykernel
- ffmpeg
================================================
FILE: notebooks/ch01_Introduction.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 1. Introduction"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"%matplotlib inline\n",
"\n",
"from prml.preprocess import PolynomialFeature\n",
"from prml.linear import (\n",
" LinearRegression,\n",
" RidgeRegression,\n",
" BayesianRegression\n",
")\n",
"\n",
"np.random.seed(1234)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.1. Example: Polynomial Curve Fitting"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"def create_toy_data(func, sample_size, std):\n",
" x = np.linspace(0, 1, sample_size)\n",
" t = func(x) + np.random.normal(scale=std, size=x.shape)\n",
" return x, t\n",
"\n",
"def func(x):\n",
" return np.sin(2 * np.pi * x)\n",
"\n",
"x_train, y_train = create_toy_data(func, 10, 0.25)\n",
"x_test = np.linspace(0, 1, 100)\n",
"y_test = func(x_test)\n",
"\n",
"plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n",
"plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 4 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"for i, degree in enumerate([0, 1, 3, 9]):\n",
" plt.subplot(2, 2, i + 1)\n",
" feature = PolynomialFeature(degree)\n",
" X_train = feature.transform(x_train)\n",
" X_test = feature.transform(x_test)\n",
"\n",
" model = LinearRegression()\n",
" model.fit(X_train, y_train)\n",
" y = model.predict(X_test)\n",
"\n",
" plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n",
" plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n",
" plt.plot(x_test, y, c=\"r\", label=\"fitting\")\n",
" plt.ylim(-1.5, 1.5)\n",
" plt.annotate(\"M={}\".format(degree), xy=(-0.15, 1))\n",
"plt.legend(bbox_to_anchor=(1.05, 0.64), loc=2, borderaxespad=0.)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"def rmse(a, b):\n",
" return np.sqrt(np.mean(np.square(a - b)))\n",
"\n",
"training_errors = []\n",
"test_errors = []\n",
"\n",
"for i in range(10):\n",
" feature = PolynomialFeature(i)\n",
" X_train = feature.transform(x_train)\n",
" X_test = feature.transform(x_test)\n",
"\n",
" model = LinearRegression()\n",
" model.fit(X_train, y_train)\n",
" y = model.predict(X_test)\n",
" training_errors.append(rmse(model.predict(X_train), y_train))\n",
" test_errors.append(rmse(model.predict(X_test), y_test + np.random.normal(scale=0.25, size=len(y_test))))\n",
"\n",
"plt.plot(training_errors, 'o-', mfc=\"none\", mec=\"b\", ms=10, c=\"b\", label=\"Training\")\n",
"plt.plot(test_errors, 'o-', mfc=\"none\", mec=\"r\", ms=10, c=\"r\", label=\"Test\")\n",
"plt.legend()\n",
"plt.xlabel(\"degree\")\n",
"plt.ylabel(\"RMSE\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Regularization"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"feature = PolynomialFeature(9)\n",
"X_train = feature.transform(x_train)\n",
"X_test = feature.transform(x_test)\n",
"\n",
"model = RidgeRegression(alpha=1e-3)\n",
"model.fit(X_train, y_train)\n",
"y = model.predict(X_test)\n",
"\n",
"y = model.predict(X_test)\n",
"plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n",
"plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n",
"plt.plot(x_test, y, c=\"r\", label=\"fitting\")\n",
"plt.ylim(-1.5, 1.5)\n",
"plt.legend()\n",
"plt.annotate(\"M=9\", xy=(-0.15, 1))\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.2.6 Bayesian curve fitting"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"model = BayesianRegression(alpha=2e-3, beta=2)\n",
"model.fit(X_train, y_train)\n",
"\n",
"y, y_err = model.predict(X_test, return_std=True)\n",
"plt.scatter(x_train, y_train, facecolor=\"none\", edgecolor=\"b\", s=50, label=\"training data\")\n",
"plt.plot(x_test, y_test, c=\"g\", label=\"$\\sin(2\\pi x)$\")\n",
"plt.plot(x_test, y, c=\"r\", label=\"mean\")\n",
"plt.fill_between(x_test, y - y_err, y + y_err, color=\"pink\", label=\"std.\", alpha=0.5)\n",
"plt.xlim(-0.1, 1.1)\n",
"plt.ylim(-1.5, 1.5)\n",
"plt.annotate(\"M=9\", xy=(0.8, 1))\n",
"plt.legend(bbox_to_anchor=(1.05, 1.), loc=2, borderaxespad=0.)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"anaconda-cloud": {},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
================================================
FILE: notebooks/ch02_Probability_Distributions.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2. Probability Distributions"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"%matplotlib inline\n",
"\n",
"from prml.rv import (\n",
" Bernoulli,\n",
" Beta,\n",
" Categorical,\n",
" Dirichlet,\n",
" Gamma,\n",
" Gaussian,\n",
" MultivariateGaussian,\n",
" MultivariateGaussianMixture,\n",
" StudentsT,\n",
" Uniform\n",
")\n",
"\n",
"np.random.seed(1234)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.1 Binary Variables"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bernoulli(\n",
" mu=0.75\n",
")\n"
]
}
],
"source": [
"model = Bernoulli()\n",
"model.fit(np.array([0., 1., 1., 1.]))\n",
"print(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.1.1 The beta distributions"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD8CAYAAABq6S8VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3dd3yT1/X48c+VLO+FFxhshjEYs4cZDiRASAglewIZhC9kktFmNv2l/TZd36ZtQlNa0oYUmk0GDYE2hCQkrBCzV1hmGoMZtjE23ras+/tDhpAEsCzr0SPJ5/2qGxlLOkdwdHx1n/vcR2mtEUII4b8sZicghBCiZaSRCyGEn5NGLoQQfk4auRBC+Dlp5EII4eekkQshhJ9rspErpUKVUuuUUluVUjuUUr/yRmJCGE1qWwQK1dQ6cqWUAiK01hVKKRvwFfBjrfUabyQohFGktkWgCGrqDtrZ6Ssav7U1fslZRMLvSW2LQNFkIwdQSlmBjUA6MEtrvfY897kPuA8gJDxykI5uR2ZyNEEW5cl8RSt1oKgSgLTECDZu3FistU70xPM2Vdvn1nVERMSgHj16eCKsED/QkrpucmrlO3dWKhZYADyitd5+ofulZfbVjut/T87PLic5JsydvIT4jhtmrSY6zMYbU4eglNqotc7y5PO7UttZWVl6w4YNngwrxFktqetmrVrRWpcCy4BxF33SxkF4bb3DnZyE+IFau4OQIOMWWbla20L4IldWrSQ2jlZQSoUBVwK7m3gM4HzzCeEJtfYGjzdyd2pbCF/kyhx5MvB641yiBXhfa/3fiz1AnRmR2xtamp8QgPPTXUiQ1dNP2+zaFsIXubJqZRswoDlPapERufCwWruDEJtnR+Tu1LYQvsiQSccz61Rkjlx4ihFTK0IECkPeGd+OyGVqRXiG82Cnx6dWhAgIxozIGxt5jYzIhQc4HJo6u4NQD0+tCBEoDBqRO/8rI3LhCXUNzgGBjMiFOD+DRuTO/3rzYGdtbS0TJkwgPT2doUOHkpeXd977TZ06laSkJHr37u213ETLnDnW0lrnyFeuXMnAgQMJCgpi/vz5ZqcjfJChUyu19d4bkc+ZM4c2bdqwb98+HnvsMX7605+e935TpkxhyZIlXstLtNyZT3aeXrXiLzp27Mhrr73G7bffbnYqwkcZPLXi3oj8hhtuYNCgQfTq1YvZs2e79JiFCxdy9913A3DLLbfwxRdfcL7tBy677DLi4uLcykuY40wdBcLUiju13blzZ/r27YvF0jp/kYmmubRpVnO19MzOuXPnEhcXR3V1NYMHD+bmm29m+vTp5Obm/uC+jz/+OJMnT6agoIDU1FQAgoKCiImJ4eTJkyQkJLj/QoRPODsiD4CpFXdqW4imGNPIgSCLcvtg58yZM1mwYAEAhw8fZu/evbz33nsezFD4k5oAmiOX2hZGMKSRg/NN584JQcuXL2fp0qXk5OQQHh7OqFGjqKmpYcKECRcdtXTo0IHDhw+TkpKC3W6nrKyM+Ph4T7wUYbKzUys2/55acbe2hWiKcY3cZqXGjRF5WVkZbdq0ITw8nN27d7NmjfNiLU2NWq677jpef/11srOzmT9/PpdffvnZKR7h384cNA/18xG5u7UtRFMMe2e4OyIfN24cdrudzMxMnnnmGYYNG+bS46ZNm8bJkydJT09nxowZPP/88wAcPXqU8ePHn73fpEmTyM7OJjc3l5SUFObMmdPsHIV3BcqI3N3aXr9+PSkpKXzwwQfcf//99OrVy+BMhb8xdmrFjYOdISEhfPLJJ81+XGhoKB988MEP/rx9+/YsXrz47Pfz5s1r9nMLcwXKwU53a3vw4MEcOXLEgIxEoDBwRG6VMzuFR3y7/NC/G7kQRjHsnRFqc29ELsT3nT2z08+nVoQwirEjctk0S3hAoEytCGEU4xq5zSJTK8IjZGpFiIszdtWKm1MreXl5bm1qpbXm0UcfJT09nb59+7Jp06bz3u/ZZ58lNTWVyMhIt/IT3hUop+i7W9e7d+8mOzubkJAQXnjhBQMyE/7O0KmVGi9umgXwySefsHfvXvbu3cvs2bN58MEHz3u/a6+9lnXr1nk1N+G+mvoGLAps1tZ5XkBcXBwzZ87kySefNDsV4aN8ckQOYLfbueOOO8jMzOSWW26hqqqqyccsXLiQyZMno5Ri2LBhlJaWcuzYsR/cb9iwYSQnJ7udm/CuM1cHCoQTvNyp66SkJAYPHozNZvNChsIfGXhmZ8saeW5uLnPmzGH48OFMnTqVl19+mYKCApYtW/aD+06cOJFnnnnmOxtnAaSkpFBQUCBN28/V1jcEzBa27tS1EE0x8IQga4v2I09NTWX48OEA3HnnncycOZOPPvrIU+kJP+IckQdGI5e6Fkbw2RH59z9GK6V47LHHLjpyObNx1hlHjhyhQ4cObucgfEMgXXjZnboWoinGjsjtDrTWbs1t5ufnk5OTQ3Z2Nu+88w4jRozgiSeeuOhjrrvuOv72t78xceJE1q5dS0xMjEyrBIBae0PAjMjdqWshmtLku0MplaqUWqaU2qmU2qGU+rErT3zmjXfmwrnNlZGRwaxZs8jMzOTUqVMXXIFyrvHjx5OWlkZ6ejr33nsvL7/88tmf9e/f/+ztp59+mpSUFKqqqkhJSeG5555zK0fhHbX1DkPmyN2t7ZZwp66PHz9OSkoKM2bM4Le//S0pKSmcPn3a6FSFH3FlRG4HntBab1JKRQEblVKfa613XuxBZxq5Ox+LO3fuzO7du5v1GHB+TJ01a9Z5f7Zly5azt//4xz/yxz/+sdnPL8xh4NSKW7XtLnfrul27drJplrioJoc5WutjWutNjbfLgV1AkxPPZ/bFkNP0RUvV2hsINWBE7m5tC+FrmvXuUEp1BgYAa8/zs/uUUhuUUhuKiorOjsi9fVKQCDw19cYf7LxQbX+/roXwRS43cqVUJPBv4Cda6x9M0GmtZ2uts7TWWYmJiYSeGZHLDoiihYw+2Hmx2v5+XQvhi1x6dyilbDgL/W2t9YeuPObbOXIZkYuWMXIduTu1LYSvcWXVigLmALu01jNcfeJzD3YK0RK1Bk2tuFvbQvgaV4Y5w4G7gMuVUlsav8Y39aAzbzw52ClaqtZu2Cn6btW2EL6myeWHWuuvgGaf0XPmjSdTK6KljJpacbe2hfA1hu5+CDK1IloukE7RF8IIBl6zU1atiJazNzhocGhD1pELESgMH5HLOnLREjUBcnUgIYxkWCOPCHZOv1fU2I0KIVqBM/UTHiKNXIgLMayRx4TZCLIoiitqjQohWoEz9ZMQGWJyJkL4LsMaucWiiI8MlkYuWqRIGrkQTTL0CFJCZAjFFXVGhhABrrjc2cgTpZELcUFeaOQyIhfuOzMQSIgKNjkTIXyX8Y28XBq5cF9xRS3hwVbCgw27mJUQfs/YRh4VTHFFHVprI8OIAFZcUSvz40I0wdBGnhgZQl2Dg9OyBFG4ydnIZVpFiIsxfGoFkHly4bbi8joZkQvRBO80cpknF24qrqglIUoauRAXY/gcOSBLEIVb7A0OSqpkRC5EU2RqRfiskqo6tIZEmSMX4qIMbeRtwoOxKGnkwj3F5Y1ryGVELsRFGdrIrRZFXIScFCTcc3afFZkjF+KiDN/kOSEymKJymSMXzScbZgnhGsMbeWKUjMiFe75t5DJHLsTFeGFELo1cuKe4oo6QIAuRIXJ6vhAXY3gjbxcTyonTNdQ3yCXfRPMUnKqmXUwoSsn1kYW4GMMbefe2kdQ3aA4WVxodSgSY3cdP071tlNlpCOHzDG/kGW2jAdh9vNzoUCKA1NQ3kHeyih7tpJEL0RTDG3nXpAisFsUeaeSiGfYXVdDg0GRIIxeiSU02cqXUXKVUoVJquzsBQoKsdEmIkBG5aJbcxnrJMHBqpaW1LYSvcGVE/howriVBMtpFkXvidEueQrQyucfLCbZa6JwQYWSY12hhbQvhC5pc16W1XqmU6tySIBlto/h42zEqa+1EyFIy4YLcE+WkJUZgsxo3+9fc2j5QVMmEV3IMy0cId3nsXaKUuk8ptUEptaGoqOg7Pzszz7nnhEyvCNfkHi/3iQOd59Z1fX292ekIcV4eGx5rrWcDswGysrK+c223M2/I3OPlDOjYxlMhRYAqq67nWFkNGe2izU7lB3X93v3ZJmckAtX7D7j/WMNXrQCktgmnTbiNdXkl3ggn/Nz6g8466ZcSY3ImQvgHrzRyi0VxabdEVu4pwuGQCzGLi1u+p5DwYCuDOsunNyFc4cryw3lADpChlDqilJrmTqBRGYkUV9Sx85isXhEXprVmeW4Rl3RNICTIamgsT9W2EGZzZdXKJE8EurRbIgAr9hTRu4N8ZBbnd7C4kiOnqrl/ZFfDY3mqtoUwm1emVsC5nW2fDjEszy30Vkjhh5bnOlc8jeqeaHImQvgPrzVygNEZiWzKL+XE6RpvhhV+ZMn243RNjCA1LtzsVITwG15t5DcPSsGhNe+szfdmWOEndh8/zbq8EiYMTjU7FSH8ilcbeaf4CEZ2T2TeunzZn1z8wJs5hwgJsnDrIGnkQjSHVxs5wOTsThSW17Jk+3FvhxY+7HRNPQs2F3Btv/a0iZBLuwnRHF5v5CO7J5GWGMGfl+6RUbk46+Vl+6mqa2DKJZ3NTkUIv+P1Rm61KJ4dn8mBokreyDnk7fDCBx06Wcncrw5y88AUWZoqhBu83sgBLu+RxKXdEnhp6R6OllabkYLwEQ6H5peLdmCzKn46LsPsdITwS6Y0cqUUv76+Nw6H5pF5m2WKpRWbveoAy3OLeHpcD5KiQ81ORwi/ZEojB+iSEMHzN/dl46FTPLdoB1rLHiytzYo9Rfzp01yu7pPM5OxOZqcjhN8y9SoP1/Zrz/ajZbyy4gDhwVb+3/hMlFJmpiS85Ot9xdz3xgYy2kbx/M195N9diBYw/XI9z4zrQU1dA6+uOsjJyjp+f1MfwzdLEuZasPkIP53/DZ0Twnlz2hCiQm1mpySEXzO9kSuleO66XsRHhjDj8z3sPVHBnyf0Iz3J/KvDCM+qqrPzf4t38daafIalxfH3OwbJmnEhPMC0OfJzKaV4dEw3Zt81iILSasbP/IoXP8ulqs5udmrCA7TWLNl+jKteWsnba/O599IuvDltqDRxITzE9BH5ucb2aseAjm34zX938tcv9zFvXT73XJrGpCEdiQmTj9/+psGh+XJ3IX9bto+th0vJaBvFu/cOY2havNmpCRFQfKqRg3O725mTBnD3JZ15aekenv9kN39Zupfr+7fnxgEdGNw5DotFDoz5ssMlVXy0uYD3Nx7mcEk1KW3C+P1Nfbh1UApBVp/4EChEQPG5Rn7GoE5teHPaULYXlPFGTh6Lth7l3fWHSYoK4YqebRnVPZGhafEyUvcB9Q0OvikoY+WeIpbuOsH2AudVoIalxfHMuEzG9mqLTRq4EIZRRqzfzsrK0hs2bPDoc1bV2fl85wmWbD/Oyj1FVNY1oBRktotmUKc29EuNpU+HGNISI6RpGEhrzfHTNWwvOM03R0rZlF/KpvxTVDX+ewxIjeWqXu24um8yKW2M2VNcKbVRa51lyJNfhBF1LcQZLalrnx2Rf194cBDX9+/A9f07UGd3sCn/FGsOnGR9XgkfbjrCm2uc+7YEWy2kJUbQNSmSLvERdIoPp1N8BB3ahNE2KkQ+2rtAa82pqnoKTlVz+FQVeScrySuuZH9RJXtPlHO6xnkQ2qKgR7tobhmUwtAu8VzSNV4OYAphAr9p5OcKDrIwLC2eYY0HzRocmoPFFWwvOM2u46fZd6KC7QVlLNl+nAbHt584LAraRoeSFB1KUlQIiVEhJEQEExcRTJuIYNqEBxMbbiMmzEZUqI2o0KCAGN07HJqKOjvlNXbKquopq66nrLqOksp6SiprKa6oo7iilsLyWorKazlWVk1N/Xe3TUiIDCEtMYJr+7WnR3I0PZOjyEyOJjzYL0tIiIASEO9Cq0WRnhRFelIUN9Dh7J/X2R0cLa0mv6SKI6eqOVZWzdHSGgrLa8g/WcWmQ6c4VVWH4yKzS6E2C5EhQUSEBBFmsxIebCU8OIhQm4UQm5Uwm5XgIAvBVgshQRaCgywEWSwEWRU2q8JqsWBVYLVasCqFRYFSoFA0/g+N8/80Gq2d3zc49He+7A6NvcFBfYODeoemtt5BXUMDdXYHtXYH1XUN1Ngd1NQ1UFVvp6qugcpaO5W1DVTW2bnYDFpUSBAJUSEkRAbTs300Y3okkRwbRofYMDrGhZMaFyYn7QjhwwKikV9IcJCFzgkRdE6IuOB9GhyaU1V1lFbVUVpVz6mqek5X13O6pp7T1XYq6+xU1NrPNsWa+gaq6uycrHRQa2+gtt7ZSGvtzqZa1+C4aNP0BJtVEWx1/tIICbI6f6kEWQkNthJms5AUFUpYsJXIYOcvoMgQK5GhQUSHOj9txITZiAm3ER8RQmy4jVCbnEkrhD8L6EbuCqtFkRAZQkJkiMees8GhqW9wYHdoGho0DfrbkbVDazTOeehzG75SzhOjFGBpHLlbLQqrRWGxKGyNo/wgi5J9SYQQ39HqG7kRnA1YRrlCCO9w6UieUmqcUipXKbVPKfWM0UkJ4S1S2yIQNNnIlVJWYBbwI6AnMEkp1dPoxIQwmtS2CBSujMiHAPu01ge01nXAu8D1xqYlhFdIbYuA4MoceQfg8DnfHwGGfv9OSqn7gPsav61VSm1veXrNlgAUt6K4ZsY28zV76uKeTda2j9Q1tM5/59b2mt2ua48d7NRazwZmAyilNphxCnVri2tmbLNfs7di+UJdmxlbXrN347r7WFemVgqA1HO+T2n8MyH8ndS2CAiuNPL1QDelVBelVDAwEVhkbFpCeIXUtggITU6taK3tSqmHgU8BKzBXa72jiYfN9kRybmhtcc2M7fev2Y3a9vvX7EdxzYztd3EN2cZWCCGE9/j/1n5CCNHKSSMXQgg/53Yjb+rUZqVUiFLqvcafr1VKdW5Jos2M/bhSaqdSaptS6gulVCdvxD3nfjcrpbRSymNLmFyJrZS6rfF171BKveONuEqpjkqpZUqpzY1/3+M9FHeuUqrwQuu2ldPMxry2KaUGeiJu43ObUttm1bUrsc+5n0dr26y6diW2X9W2cxe+5n3hPDC0H0gDgoGtQM/v3Wc68I/G2xOB99yJ5Wbs0UB44+0HPRHblbiN94sCVgJrgCwvvuZuwGagTeP3SV6KOxt4sPF2TyDPQ6/5MmAgsP0CPx8PfIJzS/dhwFov/l17vLbNqmsza9usug7E2nZ3RO7Kqc3XA6833p4PjFHKI/uvNhlba71Ma13V+O0anOuDDY/b6DfAH4AaD8RsTux7gVla61MAWutCL8XVQHTj7RjgqAfiorVeCZRc5C7XA29opzVArFIq2QOhzapts+rapdiNPF3bZtW1q7H9prbdbeTnO7W5w4Xuo7W2A2VAvJvxmhv7XNNw/nYzPG7jR6BUrfXHHojXrNhAd6C7Umq1UmqNUmqcl+I+B9yplDoCLAYe8UBcVzS3Djz5vEbUtll17VJsg2rbrLp2NfZz+EltB/R+5EqpO4EsYKQXYlmAGcAUo2NdQBDOj6GjcI7UViql+mitSw2OOwl4TWv9olIqG3hTKdVba+1o6oHCPd6s68Z4Zta2WXUNflTb7o7IXTm1+ex9lFJBOD+anHQzXnNjo5S6AngWuE5rXeuFuFFAb2C5UioP59zWIg8dFHLlNR8BFmmt67XWB4E9ON8ARsedBrwPoLXOAUJxbjpkNKNOrzerts2qa1diG1XbZtW1q7H9p7bdnKwPAg4AXfj2QEGv793nIb57QOh9Dx0ocCX2AJwHMrp5Iqarcb93/+V47mCnK695HPB64+0EnB/N4r0Q9xNgSuPtTJzziMpDr7szFz4gdDXfPSC0zot/1x6vbbPq2szaNquuA7G2W5LIeJy/HfcDzzb+2a9xjhTA+dvrA2AfsA5I82DhNRV7KXAC2NL4tcgbcY0o9ma8ZoXz4+9O4Btgopfi9gRWN74RtgBjPRR3HnAMqMc5KpsGPAA8cM7rndWY1zde/rs2pLbNqmsza9usug602pZT9IUQws+5cqm3UKXUOqXU1sYF+b/yRmJCGE1qWwSKJkfkjetjI7TWFUopG/AV8GPtXN8ohN+S2haBwpVtbDVQ0fitrfFL5mOE35PaFoHCpXXkynm18Y1AOs6zrNae5z5nr20YERExqEePHp7MU4izNm7cWKy1TvTEczVV21LXwltaUtfNOtiplIoFFgCPaK0veBHarKwsvWGD1y6rKFoZpdRG7eFrKrpS2/5U1wWl1fxn61EKTlUD0D81ljGZScSGB5ucmbiQltR1s87s1FqXKqWW4VzbadbVxIXwuECp7YpaO7/5z07e33gYraFNuI36Bs2baw4RFRLE/SPTuH9kV2xW2cE6kDTZyJVSiUB9Y6GHAVfi3DhHCL8WaLV9uKSKO+es5XBJFdOGd+HuSzqTGheOw6H5pqCMvy3bxwuf7WHV3mJm3TGQhMgQs1MWHuLKr+VkYJlSahvOi9V+rrX+r7FpCeEVAVPbR0uruf2fazhVWce792Xz82t6khoXDoDFouiXGsurk7OYcVs/thwu5bZXciiu8NQZ/sJsrqxa2Ybz1GAhAkqg1HatvYH73txAaWU9b90zlH6psRe8700DU+gQG8bd/1rHXXPW8d79w4gOtXkxW2EEmSgTws/9fvFuthecZsaE/hdt4mcMTYvnlbuy2HOinKc+2Iqc3e3/pJEL4ce+3l/Ma1/nMXV4F67s2dblx43snsjPftSDT3ecYPbKAwZmKLxBGrkQfqq+wcEvF+4gNS6Mp8dlNPvx00Z0YVyvdrzwWS67j582IEPhLQHTyGfMmEHPnj3p27cvY8aM4dChQ2anJIRH5OfnM3r0aAYMGEDfvn1ZvHgxAK9/ncfewgqeu7YXoTZrs59XKcXvbuxNdKiNJz/YSn2Dz10vQbgoYBr5gAED2LBhA9u2beOWW27h6aefNjslITzit7/9LbfddhubN2/m3XffZfr06VTU2vnbsn2M7J7ImEzXp1S+Lz4yhN/e0JvtBad5/es8zyUtvMonG/kNN9zAoEGD6NWrF7Nnz3bpMaNHjyY83LncatiwYRw5csTIFIVwizu1rZTi9Gnn1EdZWRnt27fn9a/zKK2q5/Eru7c4px/1SWZ0RiIvLd1LYbknrxkuvMWQ/chbeipzSUkJcXFxVFdXM3jwYFasWMH06dPJzc39wX0ff/xxJk+e/J0/e/jhh2nXrh0///nP3c5B+C4jTtF3hSdO0Xento8dO8bYsWM5deoUlZWVLPx4CY98XkZWpzbMmTK4RfmccbC4kqv+vJJr+iUz47b+HnlO0TxeO0XfW2bOnMmCBQsAOHz4MHv37uW9995z6bFvvfUWGzZsYMWKFUamKIRb3KntefPmMWXKFJ544glycnK4edKd2CbM4NExnrh0pVOXhAimjujCKyv3M21EF3q1j/HYcwvj+VwjX758OUuXLiUnJ4fw8HBGjRpFTU0NEyZMaHJEvnTpUn73u9+xYsUKQkLk9GPhW9yt7Tlz5rBkyRIAhgwdRkl5JWPjLS6tGW+OB0d1Zd66fP64JJfXpw7x6HMLY/lcIy8rK6NNmzaEh4eze/du1qxx7vHf1Khl8+bN3H///SxZsoSkpCRvpCpEs7hb2x07duSLL75gypQpzPnvKux1tTz4I8+fkBoTZuPh0en8bvEuvt5fzCVdvXHBeOEJPnewc9y4cdjtdjIzM3nmmWcYNmyYS4976qmnqKio4NZbb6V///5cd911BmcqRPO4W9svvvgir776Kv369eOnD91Dxq0/ZWyvZENyvCu7E22jQ3hp6V4549OP+NyIPCQkhE8++aTZj1u6dKkB2QjhOe7Wds+ePVm9ejUHiysZ/cJypl+VgdWiDMgQQm1Wpo9K55eLdpBz4KSMyv2Ez43IhRDn9/6Gw1gU3DIoxdA4Ewannh2VC/8gjVwIP2BvcDB/4xEu75FE2+hQQ2OF2qw8MLIr6w6WsCGvxNBYwjOkkQvhB1bsKaKovJbbslK9Em/i4I7ERQTz8vL9XoknWkYauRB+4KMtR2kTbmN0D++syAoLtjLlks58ubuQXcdkQy1f55ONPC8vj969ezf7cQsXLqRv377079+frKwsvvrqKwOyE8I97tZ1Za2dz3ceZ0DYScJCgpk/f74B2f3Q3dmdCQ+28qpsc+vzfLKRu2vMmDFs3bqVLVu2MHfuXO655x6zUxKixT7beZzq2nq2LXiZsWPHei1uTLiN27JSWbT1KMfLZA8WX+azjdxut3PHHXeQmZnJLbfcQlVVVZOPiYyMRCnnsqzKysqzt4XwFe7U9cItR7Hs/JQpt0/w+slu00Z0waE1r8nOiD7N59aRn5Gbm8ucOXMYPnw4U6dO5eWXX6agoIBly5b94L4TJ07kmWeeAWDBggX87Gc/o7CwkI8//tjbaQtxUc2t6wcffYLlm3ajDq1j+vS/MnXqVK/mmxoXzo96J/P22kM8cnk6ESE+2zJaNZ/9V0lNTWX48OEA3HnnncycOZOPPvqoycfdeOON3HjjjaxcuZJf/OIXcqKQ8CnNrev5G49Q9Pls/v6H/8NiMecD9NQRXfj4m2N8uOkId2V3NiUHcXE+28i/Py2ilOKxxx5rckR+xmWXXcaBAwcoLi4mIUHOThO+obl1vS95DA2F+/nfH9/L//4YiouLWbx4MUFBQdxwww1eyXlgx1j6pcTwr9V53DG0ExaDzioV7vPZRp6fn09OTg7Z2dm88847jBgxgieeeOKij9m3bx9du3ZFKcWmTZuora0lPj7eSxkL0bTm1HV5TT2DfrOUZ9/4gl9c0xOAKVOmcM0113itiYPzl83UEV348btbWLGnyGtLIIXrfPZgZ0ZGBrNmzSIzM5NTp07x4IMPNvmYf//73/Tu3Zv+/fvz0EMP8d5778kBT+FTmlPXX+4upK7BwY96t/Nihuf3o97JJEWF8C856OmTmrxCkFIqFXgDaAtoYLbW+i8Xe4wnrqQixIV46gpBza1tb9f1w+9sYs2Bk6z7f1f4xHTGX5bu5c9L95QEvA8AABokSURBVPDlEyNJS4w0O52A05K6dmVEbgee0Fr3BIYBDymleroTTAgf47O1XWd3sCK3iDE92vpEEweYNDQVm1XxRs4hs1MR39NkI9daH9Nab2q8XQ7sAjoYnZgQRvPl2l53sITyWjtX9GxrdipnJUWFcnWfZOZvPEJFrd3sdMQ5mjVHrpTqDAwA1p7nZ/cppTYopTYUFRV5JjshvORCtW1WXX++8zihNgsj0n1rxdXkSzpTUWtnweYCs1MR53C5kSulIoF/Az/RWv9gFx2t9WytdZbWOisxMdGTOQphqIvVthl1rbVm6a5CRqQnEBZs9UpMVw1IjaV3h2je+DpPriDkQ1xq5EopG85Cf1tr/aGxKQnhPb5Y23tOVFBQWs2YTN+ZVjlDKcXk7M7sLaxgzQHZq9xXNNnIlXP93hxgl9Z6hvEpCeEdvlrbX+4uBGB0hm+u176uX3tiw228kZNndiqikSsj8uHAXcDlSqktjV/jDc5LCG/wydpelltIz+Ro2sUYeyUgd4XarNyWlcpnO09w4rTsiugLXFm18pXWWmmt+2qt+zd+LfZGckIYyRdru6yqno2HTjG6h28fZ7pjaEccWvPO2nyzUxH48Cn6wj019Q0cKKrk8KkqCstrKauqo87uQOMcScWE2UiKCqFTfARdEiIIDvLZk3tbpZV7i2hwaC738dPgO8VHMLJ7IvPW5fPw5enYrFJHZpJG7ucKT9ewam8xaw6cZPPhUg4UVeA4z2ICpeD7iwxsVkVmcjTD0uIZlZHIkM5xBMkb0lQr9hQRG26jf2obs1Np0uTsTkx9bQOf7TjB1X2TzU6nVZNG7ocKSqv5z9ajfPLNMbYeKQOgTbiNgR3bML5PMt3bRtIpLoKk6BBiw20ENzbnugYHZVX1HCurIe9kJbuOlbMp/xSvrc5j9soDxEUEc33/9tw+pCPd2kaZ+RJbJYdDs2JPEZd2S8TqI2dzXszI7kmktAnjjZw8aeQmk0buJ+wNDpbuOsHba/P5al8xWkO/lBieuiqDURmJZLaLbvJU7pAgK0nRVpKiQ+mXGsv1/Z1/XllrZ9XeIhZtPcrba/L51+o8Lu2WwKNjujG4c5wXXp0A2HX8NEXltYzs7tvz42dYLYo7h3Xi+U92k3u8nIx28svfLNLIfVxVnZ156w4z96uDFJRW0yE2jEcv78ZNAzvQKT7CIzEiQoIY1zuZcb2TKamsY966fP61+iC3/iOH0RmJPHt1T9KTZJMko63Y4zxz9LJuvnU258XclpXKjM/38OaaPH57Qx+z02m1pJH7qKo6O69/fYhXVx2gpLKOIZ3j+OW1PRmT2dbQj91xEcE8NDqd/xnemTdyDjHry32Me2kl949M45HLuxFq860zDQPJitwieiZHkxTtm8sOzycuIphr+ibz4aYCnh7Xg+hQm9kptUpyZMvH2BscvL32ECP/tJw/LNlNnw4x/PvBbN5/IJuxvdp5be40PDiIB0Z2ZdlTo7i+fwdmLdvPNX/9ih1Hy7wSv7Upr3EuOxyZ4R/TKue6O7szVXUNfLjxiNmptFrSyH3I1/uKuXrmVzy7YDud48OZ/0A2r08dwqBO5s1TJ0SG8OJt/Xh96hBOV9dzw6zVvLnmkOyz4WE5+09id2gu6+Z/jbxfaiz9UmN5Q+rCNNLIfcCJ0zU89M4mbv/nWqrq7fzjzoG8f382WT50oHFk90SW/OQyRqQn8IuPtvPU/G3U2hvMTitgrNxbRESwlUGdfH/Z4fncnd2JA0WVfLWv2OxUWiVp5CZyODRvrz3EFS+u4POdJ3jsiu58/thIxvVO9slL1MVFBDPn7sE8OqYb8zce4a456yitqjM7rYCwck8x2V3j/fYErav7JhMfEczrcik4U/hn1QSAwyVV3P7PNTy7YDt9UmL47CeX8eMrfP9gosWiePzK7vxlYn+25Jcy4ZU1FMp+Gy2SV1xJfkkVl/nJssPzCQmyMmlIR77YXUj+ySqz02l1pJF7mdaaeevyueqllWwvOM3zN/Xh7XuG0jnBM0sJveX6/h2YO2Uwh09VcesrORwrqzY7Jb+1cu+ZZYf+28gB7hzWCYtSsiuiCaSRe1FJZR33vrGRn334Df1TY/n0scuYOKSjT06juGJEtwTeumcoJyvqmDR7jeyE56aVe4pJjQvzu1/m39cuJpRxvdvx3obDVMql4LxKGrmXfL2vmHEvrWTlniJ+fnUmb00bSofYMLPTarGBHdvw+tQhFJXXctectTJn3kz1DQ5y9hf7/Wj8jKnDu1BeY+ffm2QpojdJIzdYg0Mz47Nc7pizlqjQID56aDj3XJrmM1dG94RBndrw6t1Z5BVX8T+vrae6TlazuGrToVNU1jVwaYA08oEdY+mXEsNrq/NwnG/3NmEIaeQGKiqv5c5/rmXml/u4eWAK/3lkBD3bR5udliEu6ZrAzEn92XK4lMff3yJvYhet2luM1aK4JD3e7FQ8QinF1BFdOFBcyfI9hWan02pIIzfIxkMlXPPXVWw+fIo/3dKXF27tR3hwYO+IMK53Ms+Oz+ST7cd54bNcs9PxC6v2FjEgNTagTm0f3yeZdtGh/HPVQbNTaTWkkXuY1po3cvKY8MoawmxWFkwfzq1ZqWan5TXTRnRh4uBUXl6+n4+3HTM7HZ92qrKObQVlATOtcobNamHK8M58vf+kbOngJdLIPaimvoGn5m/jfxfuYGT3RBY+PILM5MCcSrkQpRS/ur4XAzvG8tT8rewrLDc7JZ+1qnE74su6+89uh66aNKQjEcFWGZV7iTRyDzlxuoYJs9cwf+MRHh3TjVcnZxETFjgfl5sjJMjK3+8cRJjNykNvb5aDnxewsvFqQH1TYs1OxeNiwmxMGNyR/2w9SkGpnGNgNGnkHrD1cCnX/vUr9p4o5x93DuLxK7sH1KoUd7SNDuWlif3ZU1jOr/6zw+x0fI7WmpV7ihienuAXVwNyx7RLuwAwR0blhpNG3kKLth7ltldyCA6y8OH0SxjXu53ZKfmMS7sl8sDIrry7/jBLth83Ox2fsvt4OYXltYwMsPnxc3WIDeO6fu15d32+nF9gMGnkbnI4NDM+38Oj8zbTLyWWRQ+PoEe71jUf7orHruhO7w7RPPPhNgrL5czPM1Y2Xg3o0gCcHz/XfSPTqKpr4DXZTMtQ0sjdUFPfwCPvbmbmF3u5dVAKb90zlLiIYLPT8knBQRZemjCAqroGnl2wXfarbrRiTxHd20aSHOP/Z/deTI920VyRmcS/VudRIaftG6bJRq6UmquUKlRKbfdGQr6uqLyWibPXsPibY/x0XA/+eEtfv9161FvSkyJ5cmx3Pt95goVbjpqdzllm1XZFrZ31eSWMykjyZljTPDQ6nbLqet5ec8jsVAKWKx3oNWCcwXn4hb0nyrlh1mp2Hz/N3+8YyIOjuvrthlfeNm1EGgM6xvLr/+6kpNJn5ktfw4Taztl/kvoGzSg/3ra2OQZ0bMOI9AReXXVAVjAZpMlGrrVeCZR4IReftnpfMTf9/WvqGhy8f38243onm52SX7FaFL+/qQ+nq+v5v8W7zE4HMK+2l+cWEhFs9akrQBnt0THdKK6o4+21Mio3gsfmBJRS9ymlNiilNhQVFXnqaX3C++sPc/fcdbSPCeOjh4YH5Lpfb+jRLpr7R6Yxf+MR1hw4aXY6LvF0XWutWZ5bxCXpCa1qSm5IlziGp8fzjxX7qaqTuXJP81glaa1na62ztNZZiYmB8ZFRa80Ln+by9L+3kd01ng8ezA6IrWfN9PDobnSIDeOXC3dQ3+AwO50mebqu9xdVUFBazchWMq1yrseu6E5xRR1v5Mio3NNaz5CgmWrtDfzkvS38bdk+Jg5OZe6UwQG1sZFZwoKt/O+1Pck9Ud4q39Bf7HLuCHh5j9ZxoPNcWZ3jGJWRyN+X76esut7sdAKKNPLzOFVZx13/XMfCLUd5elwGv7+pDzar/FV5ytiebbmseyIvLd3jSwc+veLL3YVkJkfTvpV+sntybAZl1fW8uvKA2akEFFeWH84DcoAMpdQRpdQ049MyT15xJTf9/Wu2HCll5qQBTB+VLitTPEwpxS+uzqSqroE/f77HzDy8WttlVfVsOHSKy3u0vmmVM3p3iOHafu2Z89VBuTSgB7myamWS1jpZa23TWqdored4IzEzbDxUwk1//5rSqjrevmco1/Vrb3ZKAatb2yjuGNqRd9blm7ZDordre8XeIhocmst7tDUyjM97amwGDQ7Ni7JnvcfIfEGj/247yqRX1xIdGsSH04czuBUtDTPLT67oTrjNyh+XtI439Je7ThAXEUz/1Na96qljfDh3X9KJDzYeYefR02anExBafSPXWjNr2T4efmcz/VJi+HD6cLr4+dXM/UVcRDD3j0zjs50n2HgosE9VqLM7+GJ3IWN6JAXsbofN8fDobsSG2fjVf3bItg0e0KobeZ3dwdPzt/GnT3O5vn973pwme6Z429QRXUiMCuEPn+QG9Bt67cGTlNfYGdtLdscEiAm38dRVPVh7sIRFW31n2wZ/1WobeWlVHZPnruWDxgtBvDShP6E2q9lptTrhwUE8cnk66/JK+GpfsdnpGObTHccJs1m5tFtg73bYHBMGp9KnQwz/t3gX5TWyHLElWmUj319UwY0vf82mQ6W8NKE/j1/ZXVammGjC4FTax4Ty4md7AnJU7nBoPttxgpHdE2WwcA6rRfGbG3pTWF7Lnz5tHcdJjNLqGvmqvUXcOGs1p6vreefeodwwoIPZKbV6IUFWHh3TjS2HS1meG1jbOwBsPlxKYXktV/Vu3atVzqd/aix3Z3fmzTWH2HjolNnp+K1W08i11ry2+iBT/rWe9rHOPVNa06ZFvu7mQSl0iA3jL1/sDbhR+X+3HSXYamFMpjTy83nyqgzax4Tx1Pyt1NTL7ojuaBWNvNbewM8+/Ibn/rOT0RlJzH/wElLjws1OS5zDZrUwfXRXthwuDai5codDs/ibY4zKSJQtHi4gMiSIP9zclwNFlTLF4qaAb+SFp2u4/dW1vLv+MA+PTmf2XYOIDAkyOy1xHrcMSiE5JpS/frnP7FQ8Zn1eCSdO13KNnFx2USO6JTA5uxNzvjrIqr2BN71mtIBu5BsPneKav37FzqOnmXX7QJ68KqPVX93el4UEWbnvsjTWHSwJmHXl/9l2lFCbhTGtcJOs5vrZjzLplhTJY+9tpai81ux0/EpANnKtNa9/ncfE2TmEBVtZ8NAlXN1XLgThDyYMTqVNuI2/L/f/TZVq6hv4z9ZjXNmzHRHyKbBJYcFW/nb7QMpr6nl03mbsfrDNsa8IuEZeUWvn0Xe38MtFO7isWyKLHpKr2/uT8OAgJmd3ZumuE+w9Yc4eLJ6ydNcJyqrruXVQitmp+I2MdlH87sY+5Bw4yR+W7DY7Hb8RUI1817HTXPe3r/h421GeuiqDVydnERMuB5j8zd2XdCbUZuGfqw6anUqLfLDhCO1jQhmeLicBNcctg1K4O7sTr646yPvrD5udjl8IiEautebNnDyun7Waiho7b98zjIdGp8t8uJ+KiwjmlkEpLNhS4LdzpcfKqlm1t4ibB6XI3ipu+Pk1Pbm0WwL/b8E3rNwjBz+b4veN/GRFLfe+sZFfLNxBdlo8i398Kdld481OS7TQ1OFdqLM7eHONf15F6O01+Wjg1kGpZqfil2xWCy/fMZD0pEgeeGtjwBz8NopfN/KlO09w1UsrWbmniJ9fncm/pgwmITLE7LSEB6QlRnJFZhJvrTnkdyeJ1NQ38M66fK7MbEvHeDlfwV1RoTbemDaEttGhTJm7ns35cubnhfhlIy+rqueJ97dyzxsbSIgMYdEjw7nn0jSZSgkw/zO8CyWVdfx32zGzU2mWhVsKKKmsY+qILman4veSokJ5+56hxEUGc+c/1/L1/sA5WcyT/KqRa+08S+6KP6/goy0FPDw6nUUPy6qUQHVJ13i6JUXy2tcH/ea0/QaH5tVVB8lMjmZoF9kCwhPax4bxwf3ZdGgTxt1z1/HhpiNmp+Rz/KaRHzpZydTX1jP97U0kRoaw8KHhPHlVBsFBfvMSRDMppbj7ks5sLzjtNxsqLdxSwL7CCh65XK716klJ0aF8cP8lZHWK4/H3t/K7j3dSL+vMz/L5LlhRa+dPn+7myj+vZN3BEn5+dSaLHh5O7w4xZqcmvOCmgR2ICg3iLT846Flnd/DS0r30ah/NOLmAhMfFhNt4feoQJjcuTbztlRwOFleanZZP8NlGXt/gXLEw6k/LmbVsP+N7t+PLJ0dxz6VpBFl9Nm3hYeHBQdw8MIXF3xznZIVvL0V8/es88kuqeHKsbAVhlOAgC7++vjd/nTSA/YUVjP/LKl5ZsZ86e+senftcR6yzO3hvfT6Xv7icX3y0nbSECBZMv4SXJg6gbXSo2ekJE9wxtCN1DQ4+2Oi7c6MHiyt54bNcrshsy6iMRLPTCXjX9mvPZ4+NZHh6Ar//ZDfj/rKSxd8c85tjKZ7mMxtAlFbV8d76w/xrdR7HT9fQNyWGX1/Xm1EZiTLX2Mp1axvFkC5xvLM2n/suTTM7nR+otTfw5AdbCQ6y8Lsbe0u9ekm7mFD+eXcWX+w6we8/2c30tzfRvW0k91yaxrV92xMW3HquxmRqI3c4NOvzSnh/wxE+/uYoNfUOstPief7mPozsLg1cfOuOoR358btb+Hr/SbNT+Q6HQ/P0/G1sPHSKmZPkU6MZxmS2ZVRGEou2FvDKigM8PX8bv/nvTq7pm8zVfdozpEtcwC+KcKmRK6XGAX8BrMA/tdbPuxuwpr6BDXmnWLrrBJ/uOM6xshoiQ4K4cUAKk7M7kZksSwnFD13Vqx2x4TbeXZ/v0edtSW1X1Np55t/b+O+2Yzx1VQbXyZ7jprFaFDcOSOGG/h1Ye7CEd9fls3DLUeatO0xkSBDD0uIY3DmOfqmx9GwfHXAX+WiykSulrMAs4ErgCLBeKbVIa73zYo+rtTdwqrKegtJqDhZXknv8NFsOl7L1SBl1dgchQRYu7ZbAMz/qwZU92xIe7DOzPMIHhdqs3Digg0dXr7hT2w6HJr+kii93FzJ39UGOllbz9LgMHhzZ1WN5CfcppRiWFs+wtHiq6xpYtbeIZblFrD1wkqW7Cs/er110KJ3iw0lpE0772FASo0KIiwgmJsxGVKiNyBArYcFBhARZCAmyYLNaCLIorBblkzMFrnTPIcA+rfUBAKXUu8D1wAWLfXtBGRk/X/KdPwsOstCrfTSTh3VieHoCQ9PipHmLZpk0pCP/Wp3nyadsVm1vP1pG+rOLcTQeTxvYMZYXbu3HsDTZ28cXhQVbGdurHWMbl4IWV9TyTUEZu4+Vs7ewnPyTVazeV0xhec3Zf1NXWJTzE4BCoRSc6esK541z+7y3Wr4rnbQDcO5ekkeAod+/k1LqPuC+xm9rD/3hmu3fv89e4CM3kmyGBMCMc3jNimtmbDNfc4aHnqfJ2v5+XR98/tu6PgQs8FAiLmiN/86t7TW7XdceGxJrrWcDswGUUhu01lmeem5Xtba4ZsY2+zV7K5Yv1LWZseU1ezeuu4915VBuAXDuXpwpjX8mhL+T2hYBwZVGvh7oppTqopQKBiYCi4xNSwivkNoWAaHJqRWttV0p9TDwKc4lWnO11juaeNhsTyTnhtYW18zYfv+a3ahtv3/NfhTXzNh+F1e11lNahRAiUAT26U5CCNEKSCMXQgg/53YjV0qNU0rlKqX2KaWeOc/PQ5RS7zX+fK1SqnNLEm1m7MeVUjuVUtuUUl8opTp5I+4597tZKaWVUh5bwuRKbKXUbY2ve4dS6h1vxFVKdVRKLVNKbW78+x7vobhzlVKFSqkfnI/Q+HOllJrZmNc2pdRAT8RtfG5TatusunYl9jn382htm1XXrsT2q9rWWjf7C+eBof1AGhAMbAV6fu8+04F/NN6eCLznTiw3Y48GwhtvP+iJ2K7EbbxfFLASWANkefE1dwM2A20av0/yUtzZwIONt3sCeR56zZcBA4HtF/j5eOATnCfPDQPWevHv2uO1bVZdm1nbZtV1INa2uyPys6c2a63rgDOnNp/reuD1xtvzgTFKeWSTgiZja62Xaa2rGr9dg3N9sOFxG/0G+ANQ44GYzYl9LzBLa30KQGtdSMu5ElcDZ3Y6iwGOeiAuWuuVQMlF7nI98IZ2WgPEKqWSPRDarNo2q65dit3I07VtVl27GttvatvdRn6+U5s7XOg+Wms7UAZ4YlMKV2KfaxrO326Gx238CJSqtf7YA/GaFRvoDnRXSq1WSq1Rzl39vBH3OeBOpdQRYDHwiAfiuqK5deDJ5zWits2qa5diG1TbZtW1q7Gfw09qO6B3rVJK3QlkASO9EMsCzACmGB3rAoJwfgwdhXOktlIp1UdrXWpw3EnAa1rrF5VS2cCbSqneWuvWfe0tA3mzrhvjmVnbZtU1+FFtuzsid+XU5rP3UUoF4fxo4omrArh0WrVS6grgWeA6rbUnLvbYVNwooDewXCmVh3Nua5GHDgq58pqPAIu01vVa64PAHpxvAKPjTgPeB9Ba5wChODcdMppRp9ebVdtm1bUrsY2qbbPq2tXY/lPbbk7WBwEHgC58e6Cg1/fu8xDfPSD0vocOFLgSewDOAxndPBHT1bjfu/9yPHew05XXPA54vfF2As6PZvFeiPsJMKXxdibOeUTlodfdmQsfELqa7x4QWufFv2uP17ZZdW1mbZtV14FY2y1JZDzO3477gWcb/+zXOEcK4Pzt9QGwD1gHpHmw8JqKvRQ4AWxp/FrkjbhGFHszXrPC+fF3J/ANMNFLcXsCqxvfCFuAsR6KOw84BtTjHJVNAx4AHjjn9c5qzOsbL/9dG1LbZtW1mbVtVl0HWm3LKfpCCOHn5MxOIYTwc9LIhRDCz0kjF0IIPyeNXAgh/Jw0ciGE8HPSyIUQws9JIxdCCD/3/wGrlvB48YRUUwAAAABJRU5ErkJggg==\n",
"text/plain": [
"<Figure size 432x288 with 4 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"x = np.linspace(0, 1, 100)\n",
"for i, [a, b] in enumerate([[0.1, 0.1], [1, 1], [2, 3], [8, 4]]):\n",
" plt.subplot(2, 2, i + 1)\n",
" beta = Beta(a, b)\n",
" plt.xlim(0, 1)\n",
" plt.ylim(0, 3)\n",
" plt.plot(x, beta.pdf(x))\n",
" plt.annotate(\"a={}\".format(a), (0.1, 2.5))\n",
" plt.annotate(\"b={}\".format(b), (0.1, 2.1))\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 2 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"beta = Beta(2, 2)\n",
"plt.subplot(2, 1, 1)\n",
"plt.xlim(0, 1)\n",
"plt.ylim(0, 2)\n",
"plt.plot(x, beta.pdf(x))\n",
"plt.annotate(\"prior\", (0.1, 1.5))\n",
"\n",
"model = Bernoulli(mu=beta)\n",
"model.fit(np.array([1]))\n",
"plt.subplot(2, 1, 2)\n",
"plt.xlim(0, 1)\n",
"plt.ylim(0, 2)\n",
"plt.plot(x, model.mu.pdf(x))\n",
"plt.annotate(\"posterior\", (0.1, 1.5))\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Maximum likelihood estimation\n",
"10000 out of 10000 is 1\n",
"Bayesian estimation\n",
"6649 out of 10000 is 1\n"
]
}
],
"source": [
"print(\"Maximum likelihood estimation\")\n",
"model = Bernoulli()\n",
"model.fit(np.array([1]))\n",
"print(\"{} out of 10000 is 1\".format(model.draw(10000).sum()))\n",
"\n",
"print(\"Bayesian estimation\")\n",
"model = Bernoulli(mu=Beta(1, 1))\n",
"model.fit(np.array([1]))\n",
"print(\"{} out of 10000 is 1\".format(model.draw(10000).sum()))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.2 Multinomial Variables"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Categorical(\n",
" mu=[0.5 0.25 0.25]\n",
")\n"
]
}
],
"source": [
"model = Categorical()\n",
"model.fit(np.array([[0, 1, 0], [1, 0, 0], [1, 0, 0], [0, 0, 1]]))\n",
"print(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2.1 The Dirichlet distribution"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Categorical(\n",
" mu=Dirichlet(\n",
" alpha=[1. 1. 1.]\n",
" )\n",
")\n",
"Categorical(\n",
" mu=Dirichlet(\n",
" alpha=[3. 2. 1.]\n",
" )\n",
")\n"
]
}
],
"source": [
"mu = Dirichlet(alpha=np.ones(3))\n",
"model = Categorical(mu=mu)\n",
"print(model)\n",
"\n",
"model.fit(np.array([[1., 0., 0.], [1., 0., 0.], [0., 1., 0.]]))\n",
"print(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.3 The Gaussian Distribution"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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
gitextract_qpn122o6/
├── .github/
│ ├── FUNDING.yml
│ └── workflows/
│ └── run-notebooks.yaml
├── .gitignore
├── .pre-commit-config.yaml
├── LICENSE
├── README.md
├── environment.yaml
├── notebooks/
│ ├── ch01_Introduction.ipynb
│ ├── ch02_Probability_Distributions.ipynb
│ ├── ch03_Linear_Models_for_Regression.ipynb
│ ├── ch04_Linear_Models_for_Classfication.ipynb
│ ├── ch05_Neural_Networks.ipynb
│ ├── ch06_Kernel_Methods.ipynb
│ ├── ch07_Sparse_Kernel_Machines.ipynb
│ ├── ch08_Graphical_Models.ipynb
│ ├── ch09_Mixture_Models_and_EM.ipynb
│ ├── ch10_Approximate_Inference.ipynb
│ ├── ch11_Sampling_Methods.ipynb
│ ├── ch12_Continuous_Latent_Variables.ipynb
│ └── ch13_Sequential_Data.ipynb
├── prml/
│ ├── __init__.py
│ ├── bayesnet/
│ │ ├── __init__.py
│ │ ├── discrete.py
│ │ ├── probability_function.py
│ │ └── random_variable.py
│ ├── clustering/
│ │ ├── __init__.py
│ │ └── k_means.py
│ ├── dimreduction/
│ │ ├── __init__.py
│ │ ├── autoencoder.py
│ │ ├── bayesian_pca.py
│ │ └── pca.py
│ ├── kernel/
│ │ ├── __init__.py
│ │ ├── gaussian_process_classifier.py
│ │ ├── gaussian_process_regressor.py
│ │ ├── kernel.py
│ │ ├── polynomial.py
│ │ ├── rbf.py
│ │ ├── relevance_vector_classifier.py
│ │ ├── relevance_vector_regressor.py
│ │ └── support_vector_classifier.py
│ ├── linear/
│ │ ├── __init__.py
│ │ ├── _bayesian_logistic_regression.py
│ │ ├── _bayesian_regression.py
│ │ ├── _classifier.py
│ │ ├── _empirical_bayes_regression.py
│ │ ├── _fishers_linear_discriminant.py
│ │ ├── _least_squares_classifier.py
│ │ ├── _linear_regression.py
│ │ ├── _logistic_regression.py
│ │ ├── _perceptron.py
│ │ ├── _regression.py
│ │ ├── _ridge_regression.py
│ │ ├── _softmax_regression.py
│ │ ├── _variational_linear_regression.py
│ │ └── _variational_logistic_regression.py
│ ├── markov/
│ │ ├── __init__.py
│ │ ├── categorical_hmm.py
│ │ ├── gaussian_hmm.py
│ │ ├── hmm.py
│ │ ├── kalman.py
│ │ ├── particle.py
│ │ └── state_space_model.py
│ ├── nn/
│ │ ├── __init__.py
│ │ ├── array/
│ │ │ ├── __init__.py
│ │ │ ├── array.py
│ │ │ ├── broadcast.py
│ │ │ ├── ones.py
│ │ │ ├── reshape.py
│ │ │ └── zeros.py
│ │ ├── config.py
│ │ ├── distribution/
│ │ │ ├── __init__.py
│ │ │ ├── bernoulli.py
│ │ │ ├── categorical.py
│ │ │ ├── distribution.py
│ │ │ └── gaussian.py
│ │ ├── function.py
│ │ ├── image/
│ │ │ ├── __init__.py
│ │ │ ├── convolve2d.py
│ │ │ ├── deconvolve2d.py
│ │ │ ├── max_pooling2d.py
│ │ │ └── util.py
│ │ ├── io/
│ │ │ ├── __init__.py
│ │ │ └── io.py
│ │ ├── loss/
│ │ │ ├── __init__.py
│ │ │ ├── kl.py
│ │ │ ├── sigmoid_cross_entropy.py
│ │ │ └── softmax_cross_entropy.py
│ │ ├── math/
│ │ │ ├── __init__.py
│ │ │ ├── add.py
│ │ │ ├── divide.py
│ │ │ ├── exp.py
│ │ │ ├── log.py
│ │ │ ├── matmul.py
│ │ │ ├── mean.py
│ │ │ ├── multiply.py
│ │ │ ├── negative.py
│ │ │ ├── power.py
│ │ │ ├── product.py
│ │ │ ├── sqrt.py
│ │ │ ├── square.py
│ │ │ ├── subtract.py
│ │ │ └── sum.py
│ │ ├── network.py
│ │ ├── nonlinear/
│ │ │ ├── __init__.py
│ │ │ ├── log_softmax.py
│ │ │ ├── logit.py
│ │ │ ├── relu.py
│ │ │ ├── sigmoid.py
│ │ │ ├── softmax.py
│ │ │ ├── softplus.py
│ │ │ └── tanh.py
│ │ ├── normalization/
│ │ │ ├── __init__.py
│ │ │ └── batch_normalization.py
│ │ ├── optimizer/
│ │ │ ├── __init__.py
│ │ │ ├── ada_delta.py
│ │ │ ├── ada_grad.py
│ │ │ ├── adam.py
│ │ │ ├── gradient.py
│ │ │ ├── momentum.py
│ │ │ ├── optimizer.py
│ │ │ └── rmsprop.py
│ │ ├── queue.py
│ │ └── random/
│ │ ├── __init__.py
│ │ ├── dropout.py
│ │ ├── normal.py
│ │ ├── random.py
│ │ └── uniform.py
│ ├── preprocess/
│ │ ├── __init__.py
│ │ ├── gaussian.py
│ │ ├── label_transformer.py
│ │ ├── polynomial.py
│ │ └── sigmoidal.py
│ ├── rv/
│ │ ├── __init__.py
│ │ ├── bernoulli.py
│ │ ├── bernoulli_mixture.py
│ │ ├── beta.py
│ │ ├── categorical.py
│ │ ├── dirichlet.py
│ │ ├── gamma.py
│ │ ├── gaussian.py
│ │ ├── multivariate_gaussian.py
│ │ ├── multivariate_gaussian_mixture.py
│ │ ├── rv.py
│ │ ├── students_t.py
│ │ ├── uniform.py
│ │ └── variational_gaussian_mixture.py
│ └── sampling/
│ ├── __init__.py
│ ├── metropolis.py
│ ├── metropolis_hastings.py
│ ├── rejection_sampling.py
│ └── sir.py
├── setup.cfg
├── setup.py
└── test/
├── __init__.py
├── test_bayesnet/
│ ├── __init__.py
│ └── test_discrete.py
├── test_linear/
│ ├── __init__.py
│ ├── test_bayesian_regression.py
│ ├── test_linear_regression.py
│ ├── test_logistic_regression.py
│ └── test_ridge_regression.py
└── test_nn/
├── __init__.py
├── test_backward.py
├── test_distribution/
│ ├── __init__.py
│ ├── test_bernoulli.py
│ └── test_gaussian.py
├── test_image/
│ ├── __init__.py
│ ├── test_convolve2d.py
│ ├── test_deconvolve2d.py
│ └── test_max_pooling2d.py
├── test_loss/
│ ├── __init__.py
│ └── test_sigmoid_cross_entropy.py
├── test_math/
│ ├── __init__.py
│ ├── test_add.py
│ ├── test_log.py
│ ├── test_matmul.py
│ ├── test_multiply.py
│ └── test_negative.py
├── test_nonlinear/
│ ├── __init__.py
│ ├── test_log_softmax.py
│ ├── test_sigmoid.py
│ ├── test_softmax.py
│ └── test_tanh.py
└── test_random/
└── __init__.py
SYMBOL INDEX (720 symbols across 130 files)
FILE: prml/bayesnet/discrete.py
class DiscreteVariable (line 7) | class DiscreteVariable(RandomVariable):
method __init__ (line 12) | def __init__(self, n_class:int):
method __repr__ (line 38) | def __repr__(self):
method add_parent (line 46) | def add_parent(self, parent):
method add_child (line 49) | def add_child(self, child):
method proba (line 54) | def proba(self):
method receive_message (line 57) | def receive_message(self, message, giver, proprange):
method summarize_message (line 62) | def summarize_message(self):
method send_message (line 81) | def send_message(self, proprange=-1, exclude=None):
method observe (line 89) | def observe(self, data:int, proprange=-1):
class DiscreteProbability (line 108) | class DiscreteProbability(ProbabilityFunction):
method __init__ (line 113) | def __init__(self, table, *condition, out=None, name=None):
method __repr__ (line 158) | def __repr__(self):
method receive_message (line 164) | def receive_message(self, message, giver, proprange):
method expand_dims (line 170) | def expand_dims(x, ndim, axis):
method compute_message_to (line 174) | def compute_message_to(self, destination):
method send_message_to (line 194) | def send_message_to(self, destination, proprange=-1):
method send_message (line 198) | def send_message(self, proprange, exclude=None):
function discrete (line 213) | def discrete(table, *condition, out=None, name=None):
FILE: prml/bayesnet/probability_function.py
class ProbabilityFunction (line 1) | class ProbabilityFunction(object):
FILE: prml/bayesnet/random_variable.py
class RandomVariable (line 1) | class RandomVariable(object):
FILE: prml/clustering/k_means.py
class KMeans (line 5) | class KMeans(object):
method __init__ (line 7) | def __init__(self, n_clusters):
method fit (line 10) | def fit(self, x, iter_max=100):
method predict (line 38) | def predict(self, x):
FILE: prml/dimreduction/autoencoder.py
class Autoencoder (line 6) | class Autoencoder(nn.Network):
method __init__ (line 8) | def __init__(self, *args):
method transform (line 18) | def transform(self, x):
method forward (line 24) | def forward(self, x):
method fit (line 33) | def fit(self, x, n_iter=100, learning_rate=1e-3):
FILE: prml/dimreduction/bayesian_pca.py
class BayesianPCA (line 6) | class BayesianPCA(PCA):
method fit (line 8) | def fit(self, X, iter_max=100, initial="random"):
method _maximization (line 48) | def _maximization(self, X, Ez, Ezz):
method maximize (line 55) | def maximize(self, D, Ez, Ezz):
FILE: prml/dimreduction/pca.py
class PCA (line 4) | class PCA(object):
method __init__ (line 6) | def __init__(self, n_components):
method fit (line 18) | def fit(self, x, method="eigen", iter_max=100):
method eigen (line 52) | def eigen(self, x, *arg):
method em (line 77) | def em(self, x, iter_max):
method _expectation (line 90) | def _expectation(self, x):
method _maximization (line 97) | def _maximization(self, x, Ez, Ezz):
method transform (line 104) | def transform(self, x):
method fit_transform (line 121) | def fit_transform(self, x, method="eigen"):
method proba (line 138) | def proba(self, x):
FILE: prml/kernel/gaussian_process_classifier.py
class GaussianProcessClassifier (line 4) | class GaussianProcessClassifier(object):
method __init__ (line 6) | def __init__(self, kernel, noise_level=1e-4):
method _sigmoid (line 20) | def _sigmoid(self, a):
method fit (line 23) | def fit(self, x, t):
method predict (line 32) | def predict(self, x):
FILE: prml/kernel/gaussian_process_regressor.py
class GaussianProcessRegressor (line 4) | class GaussianProcessRegressor(object):
method __init__ (line 6) | def __init__(self, kernel, beta=1.):
method fit (line 20) | def fit(self, X, t, iter_max=0, learning_rate=0.1):
method log_likelihood (line 75) | def log_likelihood(self):
method predict (line 81) | def predict(self, X, with_error=False):
FILE: prml/kernel/kernel.py
class Kernel (line 4) | class Kernel(object):
method _pairwise (line 9) | def _pairwise(self, x, y):
FILE: prml/kernel/polynomial.py
class PolynomialKernel (line 6) | class PolynomialKernel(Kernel):
method __init__ (line 12) | def __init__(self, degree=2, const=0.):
method __call__ (line 26) | def __call__(self, x, y, pairwise=True):
FILE: prml/kernel/rbf.py
class RBF (line 6) | class RBF(Kernel):
method __init__ (line 8) | def __init__(self, params):
method __call__ (line 26) | def __call__(self, x, y, pairwise=True):
method derivatives (line 50) | def derivatives(self, x, y, pairwise=True):
method update_parameters (line 58) | def update_parameters(self, updates):
FILE: prml/kernel/relevance_vector_classifier.py
class RelevanceVectorClassifier (line 4) | class RelevanceVectorClassifier(object):
method __init__ (line 6) | def __init__(self, kernel, alpha=1.):
method _sigmoid (line 20) | def _sigmoid(self, a):
method _map_estimate (line 23) | def _map_estimate(self, x, t, w, n_iter=10):
method fit (line 31) | def fit(self, x, t, iter_max=100):
method predict (line 81) | def predict(self, x):
method predict_proba (line 102) | def predict_proba(self, x):
FILE: prml/kernel/relevance_vector_regressor.py
class RelevanceVectorRegressor (line 4) | class RelevanceVectorRegressor(object):
method __init__ (line 6) | def __init__(self, kernel, alpha=1., beta=1.):
method fit (line 23) | def fit(self, x, t, iter_max=1000):
method predict (line 76) | def predict(self, x, with_error=True):
FILE: prml/kernel/support_vector_classifier.py
class SupportVectorClassifier (line 4) | class SupportVectorClassifier(object):
method __init__ (line 6) | def __init__(self, kernel, C=np.inf):
method fit (line 20) | def fit(self, x: np.ndarray, t: np.ndarray, tol: float = 1e-8):
method lagrangian_function (line 63) | def lagrangian_function(self):
method predict (line 70) | def predict(self, x):
method distance (line 88) | def distance(self, x):
FILE: prml/linear/_bayesian_logistic_regression.py
class BayesianLogisticRegression (line 6) | class BayesianLogisticRegression(LogisticRegression):
method __init__ (line 41) | def __init__(self, alpha: float = 1.):
method fit (line 51) | def fit(
method proba (line 90) | def proba(self, x: np.ndarray):
FILE: prml/linear/_bayesian_regression.py
class BayesianRegression (line 6) | class BayesianRegression(Regression):
method __init__ (line 14) | def __init__(self, alpha: float = 1., beta: float = 1.):
method _is_prior_defined (line 29) | def _is_prior_defined(self) -> bool:
method _get_prior (line 32) | def _get_prior(self, ndim: int) -> tuple:
method fit (line 38) | def fit(self, x_train: np.ndarray, y_train: np.ndarray):
method predict (line 59) | def predict(
FILE: prml/linear/_classifier.py
class Classifier (line 1) | class Classifier(object):
FILE: prml/linear/_empirical_bayes_regression.py
class EmpiricalBayesRegression (line 6) | class EmpiricalBayesRegression(BayesianRegression):
method __init__ (line 20) | def __init__(self, alpha: float = 1., beta: float = 1.):
method fit (line 32) | def fit(
method _log_prior (line 71) | def _log_prior(self, w):
method _log_likelihood (line 74) | def _log_likelihood(self, x, y, w):
method _log_posterior (line 77) | def _log_posterior(self, x, y, w):
method log_evidence (line 80) | def log_evidence(self, x: np.ndarray, y: np.ndarray):
FILE: prml/linear/_fishers_linear_discriminant.py
class FishersLinearDiscriminant (line 9) | class FishersLinearDiscriminant(Classifier):
method __init__ (line 12) | def __init__(
method fit (line 29) | def fit(self, x_train: np.ndarray, y_train: np.ndarray):
method transform (line 63) | def transform(self, x: np.ndarray):
method classify (line 78) | def classify(self, x: np.ndarray):
FILE: prml/linear/_least_squares_classifier.py
class LeastSquaresClassifier (line 7) | class LeastSquaresClassifier(Classifier):
method __init__ (line 15) | def __init__(self, w: np.ndarray = None):
method fit (line 25) | def fit(self, x_train: np.ndarray, y_train: np.ndarray):
method classify (line 40) | def classify(self, x: np.ndarray):
FILE: prml/linear/_linear_regression.py
class LinearRegression (line 6) | class LinearRegression(Regression):
method fit (line 13) | def fit(self, x_train: np.ndarray, y_train: np.ndarray):
method predict (line 26) | def predict(self, x: np.ndarray, return_std: bool = False):
FILE: prml/linear/_logistic_regression.py
class LogisticRegression (line 6) | class LogisticRegression(Classifier):
method _sigmoid (line 14) | def _sigmoid(a):
method fit (line 17) | def fit(
method proba (line 49) | def proba(self, x: np.ndarray):
method classify (line 64) | def classify(self, x: np.ndarray, threshold: float = 0.5):
FILE: prml/linear/_perceptron.py
class Perceptron (line 6) | class Perceptron(Classifier):
method fit (line 9) | def fit(
method classify (line 38) | def classify(self, x: np.ndarray):
FILE: prml/linear/_regression.py
class Regression (line 1) | class Regression(object):
FILE: prml/linear/_ridge_regression.py
class RidgeRegression (line 6) | class RidgeRegression(Regression):
method __init__ (line 12) | def __init__(self, alpha: float = 1.):
method fit (line 22) | def fit(self, x_train: np.ndarray, y_train: np.ndarray):
method predict (line 38) | def predict(self, x: np.ndarray):
FILE: prml/linear/_softmax_regression.py
class SoftmaxRegression (line 7) | class SoftmaxRegression(Classifier):
method _softmax (line 20) | def _softmax(a):
method fit (line 25) | def fit(
method proba (line 59) | def proba(self, x: np.ndarray):
method classify (line 74) | def classify(self, x: np.ndarray):
FILE: prml/linear/_variational_linear_regression.py
class VariationalLinearRegression (line 6) | class VariationalLinearRegression(Regression):
method __init__ (line 27) | def __init__(self, beta: float = 1., a0: float = 1., b0: float = 1.):
method fit (line 45) | def fit(
method predict (line 78) | def predict(self, x: np.ndarray, return_std: bool = False):
FILE: prml/linear/_variational_logistic_regression.py
class VariationalLogisticRegression (line 8) | class VariationalLogisticRegression(LogisticRegression):
method __init__ (line 39) | def __init__(
method fit (line 67) | def fit(self, x_train: np.ndarray, t: np.ndarray, iter_max: int = 1000):
method alpha (line 104) | def alpha(self) -> float:
method proba (line 122) | def proba(self, x: np.ndarray):
FILE: prml/markov/categorical_hmm.py
class CategoricalHMM (line 6) | class CategoricalHMM(HiddenMarkovModel):
method __init__ (line 11) | def __init__(self, initial_proba, transition_proba, means):
method draw (line 38) | def draw(self, n=100):
method likelihood (line 59) | def likelihood(self, x):
method maximize (line 62) | def maximize(self, seq, p_hidden, p_transition):
FILE: prml/markov/gaussian_hmm.py
class GaussianHMM (line 7) | class GaussianHMM(HiddenMarkovModel):
method __init__ (line 12) | def __init__(self, initial_proba, transition_proba, means, covs):
method draw (line 44) | def draw(self, n=100):
method likelihood (line 65) | def likelihood(self, x):
method maximize (line 71) | def maximize(self, seq, p_hidden, p_transition):
FILE: prml/markov/hmm.py
class HiddenMarkovModel (line 4) | class HiddenMarkovModel(object):
method __init__ (line 9) | def __init__(self, initial_proba, transition_proba):
method fit (line 30) | def fit(self, seq, iter_max=100):
method expect (line 59) | def expect(self, seq):
method forward_backward (line 97) | def forward_backward(self, seq):
method filtering (line 130) | def filtering(self, seq):
method viterbi (line 153) | def viterbi(self, seq):
FILE: prml/markov/kalman.py
class Kalman (line 6) | class Kalman(StateSpaceModel):
method __init__ (line 43) | def __init__(self, system, cov_system, measure, cov_measure, mu0, P0):
method predict (line 85) | def predict(self):
method filter (line 102) | def filter(self, observed):
method filtering (line 124) | def filtering(self, observed_sequence):
method smooth (line 145) | def smooth(self):
method smoothing (line 161) | def smoothing(self, observed_sequence:np.ndarray=None):
method update_parameter (line 184) | def update_parameter(self, observation_sequence):
method fit (line 215) | def fit(self, sequence, max_iter=10):
function kalman_filter (line 223) | def kalman_filter(kalman: Kalman, observed_sequence: np.ndarray) -> tuple:
function kalman_smoother (line 246) | def kalman_smoother(kalman:Kalman, observed_sequence:np.ndarray=None):
FILE: prml/markov/particle.py
class Particle (line 8) | class Particle(StateSpaceModel):
method __init__ (line 31) | def __init__(self, init_particle, system, cov_system, nll, pdf=None):
method resample (line 63) | def resample(self):
method predict (line 67) | def predict(self):
method weigh (line 74) | def weigh(self, observed):
method filter (line 79) | def filter(self, observed):
method filtering (line 83) | def filtering(self, observed_sequence):
method transition_probability (line 93) | def transition_probability(self, particle, particle_prev):
method smooth (line 104) | def smooth(self):
method smoothing (line 115) | def smoothing(self, observed_sequence:np.ndarray=None):
FILE: prml/markov/state_space_model.py
class StateSpaceModel (line 1) | class StateSpaceModel(object):
FILE: prml/nn/array/array.py
class Array (line 7) | class Array(object):
method __init__ (line 10) | def __init__(self, value, parent=None):
method __repr__ (line 18) | def __repr__(self):
method ndim (line 22) | def ndim(self):
method shape (line 26) | def shape(self):
method size (line 30) | def size(self):
method dtype (line 34) | def dtype(self):
method backward (line 37) | def backward(self, delta=None):
method update_grad (line 52) | def update_grad(self, grad):
method cleargrad (line 58) | def cleargrad(self):
method _backward (line 62) | def _backward(self, delta):
method __add__ (line 71) | def __add__(self, arg):
method __radd__ (line 74) | def __radd__(self, arg):
method __truediv__ (line 77) | def __truediv__(self, arg):
method __rtruediv__ (line 80) | def __rtruediv__(self, arg):
method __matmul__ (line 83) | def __matmul__(self, arg):
method __rmatmul__ (line 86) | def __rmatmul__(self, arg):
method __mul__ (line 89) | def __mul__(self, arg):
method __rmul__ (line 92) | def __rmul__(self, arg):
method __neg__ (line 95) | def __neg__(self):
method __pow__ (line 98) | def __pow__(self, arg):
method __rpow__ (line 101) | def __rpow__(self, arg):
method __sub__ (line 104) | def __sub__(self, arg):
method __rsub__ (line 107) | def __rsub__(self, arg):
method flatten (line 110) | def flatten(self):
method reshape (line 113) | def reshape(self, *args):
method swapaxes (line 116) | def swapaxes(self, *args):
method mean (line 119) | def mean(self, axis=None, keepdims=False):
method prod (line 122) | def prod(self):
method sum (line 125) | def sum(self, axis=None, keepdims=False):
function array (line 129) | def array(array_like):
function asarray (line 133) | def asarray(array_like):
FILE: prml/nn/array/ones.py
function ones (line 7) | def ones(size):
FILE: prml/nn/array/reshape.py
class Reshape (line 4) | class Reshape(Function):
method _forward (line 7) | def _forward(x, shape):
method _backward (line 11) | def _backward(delta, x, shape):
function reshape (line 15) | def reshape(x, shape):
function reshape_method (line 19) | def reshape_method(x, *shape):
FILE: prml/nn/array/zeros.py
function zeros (line 7) | def zeros(size):
FILE: prml/nn/config.py
class Config (line 4) | class Config(object):
method dtype (line 11) | def dtype(self):
method dtype (line 15) | def dtype(self, dtype):
method is_updating_bn (line 22) | def is_updating_bn(self):
method is_updating_bn (line 26) | def is_updating_bn(self, flag):
method enable_backprop (line 31) | def enable_backprop(self):
method enable_backprop (line 35) | def enable_backprop(self, flag):
FILE: prml/nn/distribution/bernoulli.py
class Bernoulli (line 11) | class Bernoulli(Distribution):
method __init__ (line 14) | def __init__(self, mean=None, logit=None):
method forward (line 28) | def forward(self):
method _pdf (line 32) | def _pdf(self, x):
method _log_pdf_mu (line 35) | def _log_pdf_mu(self, x):
method _log_pdf_logit (line 38) | def _log_pdf_logit(self, x):
FILE: prml/nn/distribution/categorical.py
class Categorical (line 11) | class Categorical(Distribution):
method __init__ (line 16) | def __init__(
method _forward_gumbel_softmax (line 45) | def _forward_gumbel_softmax(self):
method _forward (line 49) | def _forward(self):
method _pdf (line 59) | def _pdf(self, x):
method _log_pdf_mean (line 62) | def _log_pdf_mean(self, x):
method _log_pdf_logit (line 65) | def _log_pdf_logit(self, x):
class CategoricalPDF (line 69) | class CategoricalPDF(Function):
method _forward (line 72) | def _forward(self, mean, x):
method _backward (line 78) | def _backward(self, delta, mean, x):
FILE: prml/nn/distribution/distribution.py
class Distribution (line 4) | class Distribution(Function):
method __init__ (line 7) | def __init__(self, data=None):
method draw (line 10) | def draw(self):
method pdf (line 14) | def pdf(self, x=None):
method _pdf (line 22) | def _pdf(self, x):
method log_pdf (line 25) | def log_pdf(self, x=None):
method _log_pdf (line 33) | def _log_pdf(self, *args, **kwargs):
FILE: prml/nn/distribution/gaussian.py
class Gaussian (line 12) | class Gaussian(Distribution):
method __init__ (line 14) | def __init__(self, mean, std):
method forward (line 20) | def forward(self):
method _log_pdf (line 27) | def _log_pdf(self, x):
class GaussianLogPDF (line 31) | class GaussianLogPDF(Function):
method _forward (line 35) | def _forward(self, x, mean, std):
method _backward (line 44) | def _backward(self, delta, x, mean, std):
class GaussianRadial (line 51) | class GaussianRadial(Distribution):
method __init__ (line 53) | def __init__(self, std, ndim: int):
method forward (line 59) | def forward(self):
method _log_pdf (line 63) | def _log_pdf(self, x):
FILE: prml/nn/function.py
class Function (line 8) | class Function(object):
method forward (line 11) | def forward(self, *args, **kwargs):
method backward (line 22) | def backward(self, delta):
method _out_depth (line 34) | def _out_depth(self):
method _autobroadcast (line 38) | def _autobroadcast(arg):
method _forward (line 41) | def _forward(self, *args, **kwargs):
method _backward (line 44) | def _backward(self, *args, **kwargs):
method _convert2array (line 48) | def _convert2array(arg):
class BroadcastTo (line 55) | class BroadcastTo(Function):
method __init__ (line 60) | def __init__(self, shape):
method _forward (line 63) | def _forward(self, x):
method _backward (line 68) | def _backward(delta, x):
function broadcast_to (line 82) | def broadcast_to(x, shape):
function broadcast (line 89) | def broadcast(args):
FILE: prml/nn/image/convolve2d.py
class Convolve2dFunction (line 9) | class Convolve2dFunction(Function):
method __init__ (line 11) | def __init__(self, kernel_size, stride, pad):
method _forward (line 27) | def _forward(self, x, y):
method _backward (line 35) | def _backward(self, delta, x, y):
class Convolve2d (line 46) | class Convolve2d(Network):
method __init__ (line 48) | def __init__(self, kernel, stride, pad):
method kernel (line 60) | def kernel(self):
method __call__ (line 63) | def __call__(self, x):
function convolve2d (line 68) | def convolve2d(x, y, stride=(1, 1), pad=(0, 0)):
FILE: prml/nn/image/deconvolve2d.py
class Deconvolve2dFunction (line 9) | class Deconvolve2dFunction(Function):
method __init__ (line 11) | def __init__(self, kernel_size, out_ch, stride, pad, shape):
method _forward (line 32) | def _forward(self, x, y):
method _backward (line 49) | def _backward(self, delta, x, y):
class Deconvolve2d (line 58) | class Deconvolve2d(Network):
method __init__ (line 60) | def __init__(self, kernel, stride, pad, shape=None):
method kernel (line 73) | def kernel(self):
method __call__ (line 76) | def __call__(self, x):
function deconvolve2d (line 80) | def deconvolve2d(x, y, stride=1, pad=0, shape=None):
FILE: prml/nn/image/max_pooling2d.py
class MaxPooling2d (line 8) | class MaxPooling2d(Function):
method __init__ (line 10) | def __init__(self, pool_size, stride, pad):
method _check_tuple (line 27) | def _check_tuple(self, tup, name):
method _forward (line 48) | def _forward(self, x):
method _backward (line 57) | def _backward(self, delta, x):
function max_pooling2d (line 72) | def max_pooling2d(x, pool_size, stride=1, pad=0):
FILE: prml/nn/image/util.py
function img2patch (line 7) | def img2patch(img, size, step=1):
function _patch2img (line 42) | def _patch2img(x, stride, shape):
function patch2img (line 69) | def patch2img(x, stride, shape):
function patch2img_no_overlap (line 79) | def patch2img_no_overlap(x, stride, shape):
FILE: prml/nn/io/io.py
function save_parameter (line 5) | def save_parameter(filename: str, parameter: dict):
function load_parameter (line 10) | def load_parameter(filename: str, parameter: dict):
function save_object (line 16) | def save_object(filename: str, obj):
function load_object (line 21) | def load_object(filename: str, obj):
FILE: prml/nn/loss/kl.py
function kl_divergence (line 10) | def kl_divergence(q, p, data=None):
function kl_bernoulli (line 34) | def kl_bernoulli(q, p):
function kl_categorical (line 41) | def kl_categorical(q, p):
function kl_gaussian (line 45) | def kl_gaussian(q, p):
FILE: prml/nn/loss/sigmoid_cross_entropy.py
class SigmoidCrossEntropy (line 6) | class SigmoidCrossEntropy(Function):
method _forward (line 10) | def _forward(x, t):
method _backward (line 14) | def _backward(delta, x, t):
function sigmoid_cross_entropy (line 21) | def sigmoid_cross_entropy(x, t):
FILE: prml/nn/loss/softmax_cross_entropy.py
class SoftmaxCrossEntropy (line 7) | class SoftmaxCrossEntropy(Function):
method _forward (line 9) | def _forward(self, x, t):
method _backward (line 13) | def _backward(self, delta, x, t):
function softmax_cross_entropy (line 19) | def softmax_cross_entropy(x, t):
FILE: prml/nn/math/add.py
class Add (line 6) | class Add(Function):
method _forward (line 10) | def _forward(x, y):
method _backward (line 14) | def _backward(delta, x, y):
class AddBias (line 18) | class AddBias(Function):
method _forward (line 21) | def _forward(x, y):
method _backward (line 25) | def _backward(delta, x, y):
class AddScalar (line 31) | class AddScalar(Function):
method _forward (line 34) | def _forward(x, y):
method _backward (line 38) | def _backward(delta, x, y):
function add (line 44) | def add(x, y):
FILE: prml/nn/math/divide.py
class Divide (line 4) | class Divide(Function):
method _forward (line 8) | def _forward(x, y):
method _backward (line 12) | def _backward(delta, x, y):
function divide (line 18) | def divide(x, y):
function rdivide (line 22) | def rdivide(x, y):
FILE: prml/nn/math/exp.py
class Exp (line 6) | class Exp(Function):
method _forward (line 8) | def _forward(self, x):
method _backward (line 12) | def _backward(self, delta, x):
function exp (line 16) | def exp(x):
FILE: prml/nn/math/log.py
class Log (line 6) | class Log(Function):
method _forward (line 9) | def _forward(x):
method _backward (line 13) | def _backward(delta, x):
function log (line 17) | def log(x):
FILE: prml/nn/math/matmul.py
class Matmul (line 4) | class Matmul(Function):
method _forward (line 7) | def _forward(x, y):
method _backward (line 11) | def _backward(delta, x, y):
function matmul (line 17) | def matmul(x, y):
function rmatmul (line 21) | def rmatmul(x, y):
FILE: prml/nn/math/mean.py
function mean (line 4) | def mean(x, axis=None, keepdims=False):
FILE: prml/nn/math/multiply.py
class Multiply (line 4) | class Multiply(Function):
method _forward (line 8) | def _forward(x, y):
method _backward (line 12) | def _backward(delta, x, y):
function multiply (line 18) | def multiply(x, y):
FILE: prml/nn/math/negative.py
class Negative (line 4) | class Negative(Function):
method _forward (line 7) | def _forward(x):
method _backward (line 11) | def _backward(delta, x):
function negative (line 15) | def negative(x):
FILE: prml/nn/math/power.py
class Power (line 6) | class Power(Function):
method _forward (line 11) | def _forward(self, x, y):
method _backward (line 15) | def _backward(self, delta, x, y):
function power (line 23) | def power(x, y):
function rpower (line 30) | def rpower(x, y):
FILE: prml/nn/math/product.py
class Product (line 6) | class Product(Function):
method __init__ (line 8) | def __init__(self, axis=None, keepdims=False):
method _forward (line 16) | def _forward(self, x):
method backward (line 23) | def backward(self, delta, x):
function prod (line 31) | def prod(x, axis=None, keepdims=False):
FILE: prml/nn/math/sqrt.py
class Sqrt (line 6) | class Sqrt(Function):
method _forward (line 8) | def _forward(self, x):
method _backward (line 12) | def _backward(self, delta, x):
function sqrt (line 16) | def sqrt(x):
FILE: prml/nn/math/square.py
class Square (line 6) | class Square(Function):
method _forward (line 9) | def _forward(x):
method _backward (line 13) | def _backward(delta, x):
function square (line 17) | def square(x):
FILE: prml/nn/math/subtract.py
class Subtract (line 4) | class Subtract(Function):
method _forward (line 10) | def _forward(x, y):
method _backward (line 14) | def _backward(delta, x, y):
function subtract (line 18) | def subtract(x, y):
function rsubtract (line 23) | def rsubtract(x, y):
FILE: prml/nn/math/sum.py
class SumAxisOrKeepdims (line 6) | class SumAxisOrKeepdims(Function):
method __init__ (line 12) | def __init__(self, axis=None, keepdims=False):
method _forward (line 18) | def _forward(self, x):
method _backward (line 21) | def _backward(self, delta, x):
class SumSimple (line 34) | class SumSimple(Function):
method _forward (line 37) | def _forward(x):
method _backward (line 41) | def _backward(delta, x):
function sum (line 45) | def sum(x, axis=None, keepdims=False):
FILE: prml/nn/network.py
class Network (line 5) | class Network(object):
method __init__ (line 7) | def __init__(self):
method setting_parameter (line 12) | def setting_parameter(self):
method set_parameter (line 16) | def set_parameter(self):
method __setattr__ (line 24) | def __setattr__(self, key, value):
method clear (line 34) | def clear(self):
FILE: prml/nn/nonlinear/log_softmax.py
class LogSoftmax (line 7) | class LogSoftmax(Function):
method _forward (line 10) | def _forward(self, x):
method _backward (line 14) | def _backward(self, delta, x):
function log_softmax (line 20) | def log_softmax(x):
FILE: prml/nn/nonlinear/logit.py
class Logit (line 6) | class Logit(Function):
method _forward (line 9) | def _forward(x):
method _backward (line 13) | def _backward(delta, x):
function logit (line 17) | def logit(x):
FILE: prml/nn/nonlinear/relu.py
class ReLU (line 4) | class ReLU(Function):
method _forward (line 7) | def _forward(x):
method _backward (line 11) | def _backward(delta, x):
function relu (line 15) | def relu(x):
FILE: prml/nn/nonlinear/sigmoid.py
class Sigmoid (line 6) | class Sigmoid(Function):
method _forward (line 8) | def _forward(self, x):
method _backward (line 12) | def _backward(self, delta, x):
function sigmoid (line 16) | def sigmoid(x):
FILE: prml/nn/nonlinear/softmax.py
class Softmax (line 6) | class Softmax(Function):
method _forward (line 8) | def _forward(self, x):
method _backward (line 12) | def _backward(self, delta, x):
function softmax (line 18) | def softmax(x):
FILE: prml/nn/nonlinear/softplus.py
class Softplus (line 6) | class Softplus(Function):
method _forward (line 9) | def _forward(x):
method _backward (line 13) | def _backward(delta, x):
function softplus (line 17) | def softplus(x):
FILE: prml/nn/nonlinear/tanh.py
class Tanh (line 6) | class Tanh(Function):
method _forward (line 8) | def _forward(self, x):
method _backward (line 12) | def _backward(self, delta, x):
function tanh (line 17) | def tanh(x):
FILE: prml/nn/normalization/batch_normalization.py
class BatchNormalizationFunction (line 10) | class BatchNormalizationFunction(Function):
method _forward (line 12) | def _forward(self, x):
method _backward (line 19) | def _backward(self, delta, x):
class BatchNormalization (line 38) | class BatchNormalization(Network):
method __init__ (line 40) | def __init__(self, ndim, scale=None, bias=None, momentum=0.9):
method __call__ (line 47) | def __call__(self, x):
FILE: prml/nn/optimizer/ada_delta.py
class AdaDelta (line 7) | class AdaDelta(Optimizer):
method __init__ (line 12) | def __init__(self, parameter: dict, rho=0.95, epsilon=1e-8):
method update (line 22) | def update(self):
FILE: prml/nn/optimizer/ada_grad.py
class AdaGrad (line 7) | class AdaGrad(Optimizer):
method __init__ (line 17) | def __init__(self, parameter: dict, learning_rate=0.001, epsilon=1e-8):
method update (line 24) | def update(self):
FILE: prml/nn/optimizer/adam.py
class Adam (line 7) | class Adam(Optimizer):
method __init__ (line 22) | def __init__(self, parameter, learning_rate=0.001, beta1=0.9, beta2=0....
method update (line 55) | def update(self):
FILE: prml/nn/optimizer/gradient.py
class Gradient (line 4) | class Gradient(Optimizer):
method __init__ (line 6) | def __init__(self, parameter, learning_rate=1e-3):
method update (line 9) | def update(self):
FILE: prml/nn/optimizer/momentum.py
class Momentum (line 6) | class Momentum(Optimizer):
method __init__ (line 8) | def __init__(self, parameter: dict, learning_rate=1e-3, momentum=0.9):
method update (line 13) | def update(self):
FILE: prml/nn/optimizer/optimizer.py
class Optimizer (line 1) | class Optimizer(object):
method __init__ (line 3) | def __init__(self, parameter: dict, learning_rate: float):
method increment_iter_count (line 11) | def increment_iter_count(self):
method minimize (line 14) | def minimize(self, loss):
method maximize (line 19) | def maximize(self, score):
method optimize (line 24) | def optimize(self, array):
method update (line 29) | def update(self):
FILE: prml/nn/optimizer/rmsprop.py
class RMSProp (line 6) | class RMSProp(Optimizer):
method __init__ (line 8) | def __init__(self, parameter: dict, learning_rate=1e-3, rho=0.9, epsil...
method update (line 14) | def update(self):
FILE: prml/nn/queue.py
class BackPropQueue (line 1) | class BackPropQueue(object):
method __init__ (line 3) | def __init__(self):
method __len__ (line 6) | def __len__(self):
method enqueue (line 9) | def enqueue(self, array):
method dequeue (line 13) | def dequeue(self, depth_to_dequeue):
FILE: prml/nn/random/dropout.py
class DropoutFunction (line 6) | class DropoutFunction(Function):
method _forward (line 8) | def _forward(self, x, drop_ratio=.5):
method _backward (line 13) | def _backward(self, delta, x, drop_ratio):
function dropout (line 17) | def dropout(x, drop_ratio=.5):
FILE: prml/nn/random/normal.py
function normal (line 7) | def normal(mean, std, size):
function truncnormal (line 12) | def truncnormal(min_, max_, scale, size):
FILE: prml/nn/random/random.py
class RandomVariable (line 4) | class RandomVariable(Function):
method __init__ (line 6) | def __init__(self, data=None, p=None):
method draw (line 15) | def draw(self):
method pdf (line 21) | def pdf(self, x=None):
method _pdf (line 28) | def _pdf(self, *args):
method log_pdf (line 31) | def log_pdf(self, x=None):
method _log_pdf (line 38) | def _log_pdf(self, *args):
method KLqp (line 41) | def KLqp(self):
FILE: prml/nn/random/uniform.py
function uniform (line 6) | def uniform(min_, max_, size):
FILE: prml/preprocess/gaussian.py
class GaussianFeature (line 4) | class GaussianFeature(object):
method __init__ (line 11) | def __init__(self, mean, var):
method _gauss (line 30) | def _gauss(self, x, mean):
method transform (line 33) | def transform(self, x):
FILE: prml/preprocess/label_transformer.py
class LabelTransformer (line 4) | class LabelTransformer(object):
method __init__ (line 14) | def __init__(self, n_classes:int=None):
method n_classes (line 18) | def n_classes(self):
method n_classes (line 22) | def n_classes(self, K):
method encoder (line 27) | def encoder(self):
method encode (line 30) | def encode(self, class_indices:np.ndarray):
method decode (line 50) | def decode(self, onehot:np.ndarray):
FILE: prml/preprocess/polynomial.py
class PolynomialFeature (line 6) | class PolynomialFeature(object):
method __init__ (line 24) | def __init__(self, degree=2):
method transform (line 36) | def transform(self, x):
FILE: prml/preprocess/sigmoidal.py
class SigmoidalFeature (line 4) | class SigmoidalFeature(object):
method __init__ (line 10) | def __init__(self, mean, coef=1):
method _sigmoid (line 35) | def _sigmoid(self, x, mean):
method transform (line 38) | def transform(self, x):
FILE: prml/rv/bernoulli.py
class Bernoulli (line 7) | class Bernoulli(RandomVariable):
method __init__ (line 13) | def __init__(self, mu=None):
method mu (line 26) | def mu(self):
method mu (line 30) | def mu(self, mu):
method ndim (line 47) | def ndim(self):
method size (line 54) | def size(self):
method shape (line 61) | def shape(self):
method _fit (line 67) | def _fit(self, x):
method _ml (line 75) | def _ml(self, x):
method _map (line 83) | def _map(self, x):
method _bayes (line 95) | def _bayes(self, x):
method _pdf (line 106) | def _pdf(self, x):
method _draw (line 110) | def _draw(self, sample_size=1):
FILE: prml/rv/bernoulli_mixture.py
class BernoulliMixture (line 6) | class BernoulliMixture(RandomVariable):
method __init__ (line 12) | def __init__(self, n_components=3, mu=None, coef=None):
method mu (line 32) | def mu(self):
method mu (line 36) | def mu(self, mu):
method coef (line 48) | def coef(self):
method coef (line 52) | def coef(self, coef):
method _log_bernoulli (line 61) | def _log_bernoulli(self, x):
method _fit (line 68) | def _fit(self, x):
method _expectation (line 80) | def _expectation(self, x):
method _maximization (line 86) | def _maximization(self, x, resp):
method classify (line 91) | def classify(self, x):
method classfiy_proba (line 108) | def classfiy_proba(self, x):
FILE: prml/rv/beta.py
class Beta (line 9) | class Beta(RandomVariable):
method __init__ (line 18) | def __init__(self, n_zeros, n_ones):
method ndim (line 51) | def ndim(self):
method size (line 55) | def size(self):
method shape (line 59) | def shape(self):
method _pdf (line 62) | def _pdf(self, mu):
method _draw (line 71) | def _draw(self, sample_size=1):
FILE: prml/rv/categorical.py
class Categorical (line 7) | class Categorical(RandomVariable):
method __init__ (line 13) | def __init__(self, mu=None):
method mu (line 26) | def mu(self):
method mu (line 30) | def mu(self, mu):
method ndim (line 49) | def ndim(self):
method size (line 56) | def size(self):
method shape (line 63) | def shape(self):
method _check_input (line 69) | def _check_input(self, x):
method _fit (line 74) | def _fit(self, x):
method _ml (line 82) | def _ml(self, x):
method _map (line 86) | def _map(self, x):
method _bayes (line 92) | def _bayes(self, x):
method _pdf (line 97) | def _pdf(self, x):
method _draw (line 102) | def _draw(self, sample_size=1):
FILE: prml/rv/dirichlet.py
class Dirichlet (line 6) | class Dirichlet(RandomVariable):
method __init__ (line 15) | def __init__(self, alpha):
method alpha (line 28) | def alpha(self):
method alpha (line 32) | def alpha(self, alpha):
method ndim (line 39) | def ndim(self):
method size (line 43) | def size(self):
method shape (line 47) | def shape(self):
method _pdf (line 50) | def _pdf(self, mu):
method _draw (line 57) | def _draw(self, sample_size=1):
FILE: prml/rv/gamma.py
class Gamma (line 9) | class Gamma(RandomVariable):
method __init__ (line 16) | def __init__(self, a, b):
method a (line 35) | def a(self):
method a (line 39) | def a(self, a):
method b (line 54) | def b(self):
method b (line 58) | def b(self, b):
method ndim (line 73) | def ndim(self):
method shape (line 77) | def shape(self):
method size (line 81) | def size(self):
method _pdf (line 84) | def _pdf(self, x):
method _draw (line 91) | def _draw(self, sample_size=1):
FILE: prml/rv/gaussian.py
class Gaussian (line 7) | class Gaussian(RandomVariable):
method __init__ (line 14) | def __init__(self, mu=None, var=None, tau=None):
method mu (line 26) | def mu(self):
method mu (line 30) | def mu(self, mu):
method var (line 43) | def var(self):
method var (line 47) | def var(self, var):
method tau (line 65) | def tau(self):
method tau (line 69) | def tau(self, tau):
method ndim (line 91) | def ndim(self):
method size (line 98) | def size(self):
method shape (line 105) | def shape(self):
method _fit (line 111) | def _fit(self, x):
method _ml (line 123) | def _ml(self, x):
method _map (line 127) | def _map(self, x):
method _bayes_mu (line 137) | def _bayes_mu(self, x):
method _bayes_tau (line 146) | def _bayes_tau(self, x):
method _bayes (line 153) | def _bayes(self, x):
method _pdf (line 174) | def _pdf(self, x):
method _draw (line 180) | def _draw(self, sample_size=1):
FILE: prml/rv/multivariate_gaussian.py
class MultivariateGaussian (line 6) | class MultivariateGaussian(RandomVariable):
method __init__ (line 14) | def __init__(self, mu=None, cov=None, tau=None):
method mu (line 26) | def mu(self):
method mu (line 30) | def mu(self, mu):
method cov (line 39) | def cov(self):
method cov (line 43) | def cov(self, cov):
method tau (line 54) | def tau(self):
method tau (line 58) | def tau(self, tau):
method ndim (line 69) | def ndim(self):
method size (line 76) | def size(self):
method shape (line 83) | def shape(self):
method _fit (line 89) | def _fit(self, x):
method _pdf (line 93) | def _pdf(self, x):
method _draw (line 100) | def _draw(self, sample_size=1):
FILE: prml/rv/multivariate_gaussian_mixture.py
class MultivariateGaussianMixture (line 7) | class MultivariateGaussianMixture(RandomVariable):
method __init__ (line 13) | def __init__(self,
method mu (line 51) | def mu(self):
method mu (line 55) | def mu(self, mu):
method cov (line 67) | def cov(self):
method cov (line 71) | def cov(self, cov):
method tau (line 83) | def tau(self):
method tau (line 87) | def tau(self, tau):
method coef (line 99) | def coef(self):
method coef (line 103) | def coef(self, coef):
method shape (line 117) | def shape(self):
method _gauss (line 123) | def _gauss(self, x):
method _fit (line 131) | def _fit(self, x):
method _expectation (line 156) | def _expectation(self, x):
method _maximization (line 161) | def _maximization(self, x, resps):
method joint_proba (line 169) | def joint_proba(self, x):
method _pdf (line 185) | def _pdf(self, x):
method classify (line 189) | def classify(self, x):
method classify_proba (line 206) | def classify_proba(self, x):
FILE: prml/rv/rv.py
class RandomVariable (line 4) | class RandomVariable(object):
method __init__ (line 7) | def __init__(self):
method __repr__ (line 11) | def __repr__(self):
method __format__ (line 24) | def __format__(self, indent="4"):
method fit (line 38) | def fit(self, x, **kwargs):
method pdf (line 100) | def pdf(self, x):
method draw (line 119) | def draw(self, sample_size=1):
method _check_input (line 138) | def _check_input(self, x):
FILE: prml/rv/students_t.py
class StudentsT (line 6) | class StudentsT(RandomVariable):
method __init__ (line 13) | def __init__(self, mu=None, tau=None, dof=None):
method mu (line 20) | def mu(self):
method mu (line 24) | def mu(self, mu):
method tau (line 34) | def tau(self):
method tau (line 38) | def tau(self, tau):
method dof (line 51) | def dof(self):
method dof (line 55) | def dof(self, dof):
method ndim (line 63) | def ndim(self):
method size (line 70) | def size(self):
method shape (line 77) | def shape(self):
method _fit (line 83) | def _fit(self, x, learning_rate=0.01):
method _expectation (line 105) | def _expectation(self, x):
method _maximization (line 113) | def _maximization(self, x, E_eta, E_lneta, learning_rate):
method _pdf (line 124) | def _pdf(self, x):
FILE: prml/rv/uniform.py
class Uniform (line 6) | class Uniform(RandomVariable):
method __init__ (line 13) | def __init__(self, low, high):
method low (line 33) | def low(self):
method low (line 38) | def low(self, low):
method high (line 42) | def high(self):
method high (line 47) | def high(self, high):
method ndim (line 51) | def ndim(self):
method size (line 56) | def size(self):
method shape (line 61) | def shape(self):
method mean (line 66) | def mean(self):
method _pdf (line 70) | def _pdf(self, x):
method _draw (line 75) | def _draw(self, sample_size=1):
FILE: prml/rv/variational_gaussian_mixture.py
class VariationalGaussianMixture (line 7) | class VariationalGaussianMixture(RandomVariable):
method __init__ (line 9) | def __init__(
method _init_params (line 46) | def _init_params(self, x):
method alpha (line 66) | def alpha(self):
method alpha (line 71) | def alpha(self, alpha):
method beta (line 75) | def beta(self):
method beta (line 80) | def beta(self, beta):
method mu (line 84) | def mu(self):
method mu (line 89) | def mu(self, mu):
method W (line 93) | def W(self):
method W (line 98) | def W(self, W):
method dof (line 102) | def dof(self):
method dof (line 107) | def dof(self, dof):
method get_params (line 110) | def get_params(self):
method _fit (line 114) | def _fit(self, x, iter_max=100):
method _variational_expectation (line 123) | def _variational_expectation(self, x):
method _variational_maximization (line 136) | def _variational_maximization(self, x, r):
method classify (line 151) | def classify(self, x):
method classify_proba (line 165) | def classify_proba(self, x):
method student_t (line 179) | def student_t(self, x):
method _pdf (line 191) | def _pdf(self, x):
FILE: prml/sampling/metropolis.py
function metropolis (line 6) | def metropolis(func, rv, n, downsample=1):
FILE: prml/sampling/metropolis_hastings.py
function metropolis_hastings (line 6) | def metropolis_hastings(func, rv, n, downsample=1):
FILE: prml/sampling/rejection_sampling.py
function rejection_sampling (line 5) | def rejection_sampling(func, rv, k, n):
FILE: prml/sampling/sir.py
function sir (line 4) | def sir(func, rv, n):
FILE: test/test_bayesnet/test_discrete.py
class TestDiscrete (line 8) | class TestDiscrete(unittest.TestCase):
method test_discrete (line 10) | def test_discrete(self):
method test_joint_discrete (line 75) | def test_joint_discrete(self):
FILE: test/test_linear/test_bayesian_regression.py
class TestBayesianRegression (line 8) | class TestBayesianRegression(unittest.TestCase):
method test_fit_predict (line 10) | def test_fit_predict(self):
FILE: test/test_linear/test_linear_regression.py
class TestLinearRegression (line 8) | class TestLinearRegression(unittest.TestCase):
method test_fit (line 10) | def test_fit(self):
method test_predict (line 21) | def test_predict(self):
FILE: test/test_linear/test_logistic_regression.py
class TestLogisticRegression (line 8) | class TestLogisticRegression(unittest.TestCase):
method test_fit_classify_proba (line 10) | def test_fit_classify_proba(self):
FILE: test/test_linear/test_ridge_regression.py
class TestRidgeRegression (line 8) | class TestRidgeRegression(unittest.TestCase):
method test_fit_predict (line 10) | def test_fit_predict(self):
FILE: test/test_nn/test_backward.py
class TestBackward (line 8) | class TestBackward(unittest.TestCase):
method test_backward (line 10) | def test_backward(self):
FILE: test/test_nn/test_distribution/test_bernoulli.py
class TestBernoulli (line 8) | class TestBernoulli(unittest.TestCase):
method test_bernoulli_kl (line 10) | def test_bernoulli_kl(self):
method test_bernoulli_mu (line 25) | def test_bernoulli_mu(self):
method test_bernoulli_logit (line 32) | def test_bernoulli_logit(self):
FILE: test/test_nn/test_distribution/test_gaussian.py
class TestGaussian (line 8) | class TestGaussian(unittest.TestCase):
method test_gaussian_draw_forward (line 10) | def test_gaussian_draw_forward(self):
method test_gaussian_draw_backward (line 20) | def test_gaussian_draw_backward(self):
FILE: test/test_nn/test_image/test_convolve2d.py
class TestConvolve2d (line 8) | class TestConvolve2d(unittest.TestCase):
method test_convolve2d_forward (line 10) | def test_convolve2d_forward(self):
method test_convolve2d_backward (line 23) | def test_convolve2d_backward(self):
method test_convolve2d_network (line 42) | def test_convolve2d_network(self):
FILE: test/test_nn/test_image/test_deconvolve2d.py
class TestDeconvolve2d (line 9) | class TestDeconvolve2d(unittest.TestCase):
method test_deconvolve2d_forward (line 11) | def test_deconvolve2d_forward(self):
method test_deconvolve2d_backward (line 24) | def test_deconvolve2d_backward(self):
FILE: test/test_nn/test_image/test_max_pooling2d.py
class TestMaxPooling2d (line 8) | class TestMaxPooling2d(unittest.TestCase):
method test_max_pooling2d (line 10) | def test_max_pooling2d(self):
FILE: test/test_nn/test_loss/test_sigmoid_cross_entropy.py
class TestSigmoidCrossEntropy (line 8) | class TestSigmoidCrossEntropy(unittest.TestCase):
method test_sigmoid_cross_entropy (line 10) | def test_sigmoid_cross_entropy(self):
FILE: test/test_nn/test_math/test_add.py
class TestAdd (line 8) | class TestAdd(unittest.TestCase):
method test_add (line 10) | def test_add(self):
method test_add_bias (line 23) | def test_add_bias(self):
method test_add_scalar (line 37) | def test_add_scalar(self):
FILE: test/test_nn/test_math/test_log.py
class TestLog (line 8) | class TestLog(unittest.TestCase):
method test_log (line 10) | def test_log(self):
FILE: test/test_nn/test_math/test_matmul.py
class TestMatmul (line 8) | class TestMatmul(unittest.TestCase):
method test_matmul (line 10) | def test_matmul(self):
FILE: test/test_nn/test_math/test_multiply.py
class TestMultiply (line 8) | class TestMultiply(unittest.TestCase):
method test_multiply (line 10) | def test_multiply(self):
method test_multiply_vector (line 23) | def test_multiply_vector(self):
method test_multiply_scalar (line 36) | def test_multiply_scalar(self):
FILE: test/test_nn/test_math/test_negative.py
class TestNegative (line 8) | class TestNegative(unittest.TestCase):
method test_negative (line 10) | def test_negative(self):
FILE: test/test_nn/test_nonlinear/test_log_softmax.py
class TestLogSoftmax (line 8) | class TestLogSoftmax(unittest.TestCase):
method test_forward (line 10) | def test_forward(self):
method test_backward (line 15) | def test_backward(self):
FILE: test/test_nn/test_nonlinear/test_sigmoid.py
class TestSigmoid (line 8) | class TestSigmoid(unittest.TestCase):
method test_sigmoid (line 10) | def test_sigmoid(self):
FILE: test/test_nn/test_nonlinear/test_softmax.py
class TestSoftmax (line 8) | class TestSoftmax(unittest.TestCase):
method test_forward (line 10) | def test_forward(self):
method test_backward (line 15) | def test_backward(self):
FILE: test/test_nn/test_nonlinear/test_tanh.py
class TestTanh (line 8) | class TestTanh(unittest.TestCase):
method test_tanh (line 10) | def test_tanh(self):
Condensed preview — 184 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (3,898K chars).
[
{
"path": ".github/FUNDING.yml",
"chars": 138,
"preview": "# These are supported funding model platforms\n\ngithub: ctgk # Replace with up to 4 GitHub Sponsors-enabled usernames e.g"
},
{
"path": ".github/workflows/run-notebooks.yaml",
"chars": 1100,
"preview": "# This workflow will install Python dependencies, run full checks defined in `.pre-commit-config.yaml` with a variety of"
},
{
"path": ".gitignore",
"chars": 1082,
"preview": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packagi"
},
{
"path": ".pre-commit-config.yaml",
"chars": 909,
"preview": "# See https://pre-commit.com for more information\n# See https://pre-commit.com/hooks.html for more hooks\nrepos:\n- repo"
},
{
"path": "LICENSE",
"chars": 1061,
"preview": "MIT License\n\nCopyright (c) 2018 ctgk\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof th"
},
{
"path": "README.md",
"chars": 5312,
"preview": "# PRML\nPython codes implementing algorithms described in Bishop's book \"Pattern Recognition and Machine Learning\"\n\n## Re"
},
{
"path": "environment.yaml",
"chars": 215,
"preview": "# run: conda env create -n environment.yaml\n# conda activate prml\n# python setup.py install\nname: prml\ndepende"
},
{
"path": "notebooks/ch01_Introduction.ipynb",
"chars": 138514,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Introduction\"\n ]\n },\n {\n "
},
{
"path": "notebooks/ch02_Probability_Distributions.ipynb",
"chars": 198171,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Probability Distributions\"\n "
},
{
"path": "notebooks/ch03_Linear_Models_for_Regression.ipynb",
"chars": 765017,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 3. Linear Models for Regression\"\n"
},
{
"path": "notebooks/ch04_Linear_Models_for_Classfication.ipynb",
"chars": 129269,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 4. Linear Models for Classificati"
},
{
"path": "notebooks/ch05_Neural_Networks.ipynb",
"chars": 443976,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 5. Neural Networks\"\n ]\n },\n {"
},
{
"path": "notebooks/ch06_Kernel_Methods.ipynb",
"chars": 241644,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 6. Kernel Methods\"\n ]\n },\n {\n"
},
{
"path": "notebooks/ch07_Sparse_Kernel_Machines.ipynb",
"chars": 146508,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 7. Sparse Kernel Machines\"\n ]\n "
},
{
"path": "notebooks/ch08_Graphical_Models.ipynb",
"chars": 19982,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 8. Graphical Models\"\n ]\n },\n "
},
{
"path": "notebooks/ch09_Mixture_Models_and_EM.ipynb",
"chars": 55086,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 9. Mixture Models and EM\"\n ]\n "
},
{
"path": "notebooks/ch10_Approximate_Inference.ipynb",
"chars": 202606,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 10. Approximate Inference\"\n ]\n "
},
{
"path": "notebooks/ch11_Sampling_Methods.ipynb",
"chars": 103112,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 11. Sampling Methods\"\n ]\n },\n "
},
{
"path": "notebooks/ch12_Continuous_Latent_Variables.ipynb",
"chars": 113345,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 12. Continuous Latent Variables\"\n"
},
{
"path": "notebooks/ch13_Sequential_Data.ipynb",
"chars": 1060189,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 13. Sequential Data\"\n ]\n },\n "
},
{
"path": "prml/__init__.py",
"chars": 281,
"preview": "from prml import (\n bayesnet,\n clustering,\n dimreduction,\n kernel,\n linear,\n markov,\n nn,\n rv,\n "
},
{
"path": "prml/bayesnet/__init__.py",
"chars": 117,
"preview": "from prml.bayesnet.discrete import discrete, DiscreteVariable\n\n\n__all__ = [\n \"DiscreteVariable\",\n \"discrete\"\n]\n"
},
{
"path": "prml/bayesnet/discrete.py",
"chars": 8388,
"preview": "import numpy as np\n\nfrom prml.bayesnet.probability_function import ProbabilityFunction\nfrom prml.bayesnet.random_variabl"
},
{
"path": "prml/bayesnet/probability_function.py",
"chars": 44,
"preview": "class ProbabilityFunction(object):\n pass\n"
},
{
"path": "prml/bayesnet/random_variable.py",
"chars": 81,
"preview": "class RandomVariable(object):\n \"\"\"\n Base class for random variable\n \"\"\"\n"
},
{
"path": "prml/clustering/__init__.py",
"chars": 72,
"preview": "from prml.clustering.k_means import KMeans\n\n\n__all__ = [\n \"KMeans\"\n]\n"
},
{
"path": "prml/clustering/k_means.py",
"chars": 1490,
"preview": "import numpy as np\nfrom scipy.spatial.distance import cdist\n\n\nclass KMeans(object):\n\n def __init__(self, n_clusters):"
},
{
"path": "prml/dimreduction/__init__.py",
"chars": 212,
"preview": "from prml.dimreduction.autoencoder import Autoencoder\nfrom prml.dimreduction.bayesian_pca import BayesianPCA\nfrom prml.d"
},
{
"path": "prml/dimreduction/autoencoder.py",
"chars": 1480,
"preview": "import numpy as np\n\nfrom prml import nn\n\n\nclass Autoencoder(nn.Network):\n\n def __init__(self, *args):\n self.n_"
},
{
"path": "prml/dimreduction/bayesian_pca.py",
"chars": 2145,
"preview": "import numpy as np\n\nfrom prml.dimreduction.pca import PCA\n\n\nclass BayesianPCA(PCA):\n\n def fit(self, X, iter_max=100, "
},
{
"path": "prml/dimreduction/pca.py",
"chars": 4925,
"preview": "import numpy as np\n\n\nclass PCA(object):\n\n def __init__(self, n_components):\n \"\"\"\n construct principal c"
},
{
"path": "prml/kernel/__init__.py",
"chars": 677,
"preview": "from prml.kernel.gaussian_process_classifier import GaussianProcessClassifier\nfrom prml.kernel.gaussian_process_regresso"
},
{
"path": "prml/kernel/gaussian_process_classifier.py",
"chars": 994,
"preview": "import numpy as np\n\n\nclass GaussianProcessClassifier(object):\n\n def __init__(self, kernel, noise_level=1e-4):\n "
},
{
"path": "prml/kernel/gaussian_process_regressor.py",
"chars": 3367,
"preview": "import numpy as np\n\n\nclass GaussianProcessRegressor(object):\n\n def __init__(self, kernel, beta=1.):\n \"\"\"\n "
},
{
"path": "prml/kernel/kernel.py",
"chars": 591,
"preview": "import numpy as np\n\n\nclass Kernel(object):\n \"\"\"\n Base class for kernel function\n \"\"\"\n\n def _pairwise(self, x"
},
{
"path": "prml/kernel/polynomial.py",
"chars": 973,
"preview": "import numpy as np\n\nfrom prml.kernel.kernel import Kernel\n\n\nclass PolynomialKernel(Kernel):\n \"\"\"\n Polynomial kerne"
},
{
"path": "prml/kernel/rbf.py",
"chars": 1625,
"preview": "import numpy as np\n\nfrom prml.kernel.kernel import Kernel\n\n\nclass RBF(Kernel):\n\n def __init__(self, params):\n "
},
{
"path": "prml/kernel/relevance_vector_classifier.py",
"chars": 3487,
"preview": "import numpy as np\n\n\nclass RelevanceVectorClassifier(object):\n\n def __init__(self, kernel, alpha=1.):\n \"\"\"\n "
},
{
"path": "prml/kernel/relevance_vector_regressor.py",
"chars": 3227,
"preview": "import numpy as np\n\n\nclass RelevanceVectorRegressor(object):\n\n def __init__(self, kernel, alpha=1., beta=1.):\n "
},
{
"path": "prml/kernel/support_vector_classifier.py",
"chars": 3016,
"preview": "import numpy as np\n\n\nclass SupportVectorClassifier(object):\n\n def __init__(self, kernel, C=np.inf):\n \"\"\"\n "
},
{
"path": "prml/linear/__init__.py",
"chars": 1260,
"preview": "\"\"\"Linear machine learning models.\"\"\"\n\nfrom prml.linear._bayesian_logistic_regression import (\n BayesianLogisticRegre"
},
{
"path": "prml/linear/_bayesian_logistic_regression.py",
"chars": 3178,
"preview": "import numpy as np\n\nfrom prml.linear._logistic_regression import LogisticRegression\n\n\nclass BayesianLogisticRegression(L"
},
{
"path": "prml/linear/_bayesian_regression.py",
"chars": 3109,
"preview": "import numpy as np\n\nfrom prml.linear._regression import Regression\n\n\nclass BayesianRegression(Regression):\n \"\"\"Bayesi"
},
{
"path": "prml/linear/_classifier.py",
"chars": 74,
"preview": "class Classifier(object):\n \"\"\"Base class for classifiers.\"\"\"\n\n pass\n"
},
{
"path": "prml/linear/_empirical_bayes_regression.py",
"chars": 3066,
"preview": "import numpy as np\n\nfrom prml.linear._bayesian_regression import BayesianRegression\n\n\nclass EmpiricalBayesRegression(Bay"
},
{
"path": "prml/linear/_fishers_linear_discriminant.py",
"chars": 2522,
"preview": "import typing as tp\n\nimport numpy as np\n\nfrom prml.linear._classifier import Classifier\nfrom prml.rv.gaussian import Gau"
},
{
"path": "prml/linear/_least_squares_classifier.py",
"chars": 1379,
"preview": "import numpy as np\n\nfrom prml.linear._classifier import Classifier\nfrom prml.preprocess.label_transformer import LabelTr"
},
{
"path": "prml/linear/_linear_regression.py",
"chars": 1269,
"preview": "import numpy as np\n\nfrom prml.linear._regression import Regression\n\n\nclass LinearRegression(Regression):\n \"\"\"Linear r"
},
{
"path": "prml/linear/_logistic_regression.py",
"chars": 2124,
"preview": "import numpy as np\n\nfrom prml.linear._classifier import Classifier\n\n\nclass LogisticRegression(Classifier):\n \"\"\"Logist"
},
{
"path": "prml/linear/_perceptron.py",
"chars": 1429,
"preview": "import numpy as np\n\nfrom prml.linear._classifier import Classifier\n\n\nclass Perceptron(Classifier):\n \"\"\"Perceptron mod"
},
{
"path": "prml/linear/_regression.py",
"chars": 73,
"preview": "class Regression(object):\n \"\"\"Base class for regressors.\"\"\"\n\n pass\n"
},
{
"path": "prml/linear/_ridge_regression.py",
"chars": 1271,
"preview": "import numpy as np\n\nfrom prml.linear._regression import Regression\n\n\nclass RidgeRegression(Regression):\n \"\"\"Ridge reg"
},
{
"path": "prml/linear/_softmax_regression.py",
"chars": 2393,
"preview": "import numpy as np\n\nfrom prml.linear._classifier import Classifier\nfrom prml.preprocess.label_transformer import LabelTr"
},
{
"path": "prml/linear/_variational_linear_regression.py",
"chars": 3032,
"preview": "import numpy as np\n\nfrom prml.linear._regression import Regression\n\n\nclass VariationalLinearRegression(Regression):\n "
},
{
"path": "prml/linear/_variational_logistic_regression.py",
"chars": 4238,
"preview": "import typing as tp\n\nimport numpy as np\n\nfrom prml.linear._logistic_regression import LogisticRegression\n\n\nclass Variati"
},
{
"path": "prml/markov/__init__.py",
"chars": 346,
"preview": "from prml.markov.categorical_hmm import CategoricalHMM\nfrom prml.markov.gaussian_hmm import GaussianHMM\nfrom prml.markov"
},
{
"path": "prml/markov/categorical_hmm.py",
"chars": 2242,
"preview": "import numpy as np\n\nfrom prml.markov.hmm import HiddenMarkovModel\n\n\nclass CategoricalHMM(HiddenMarkovModel):\n \"\"\"\n "
},
{
"path": "prml/markov/gaussian_hmm.py",
"chars": 2890,
"preview": "import numpy as np\n\nfrom prml.markov.hmm import HiddenMarkovModel\nfrom prml.rv import MultivariateGaussian\n\n\nclass Gauss"
},
{
"path": "prml/markov/hmm.py",
"chars": 5679,
"preview": "import numpy as np\n\n\nclass HiddenMarkovModel(object):\n \"\"\"\n Base class of Hidden Markov models\n \"\"\"\n\n def __"
},
{
"path": "prml/markov/kalman.py",
"chars": 9640,
"preview": "import numpy as np\n\nfrom prml.markov.state_space_model import StateSpaceModel\n\n\nclass Kalman(StateSpaceModel):\n \"\"\"A "
},
{
"path": "prml/markov/particle.py",
"chars": 4493,
"preview": "import numpy as np\nfrom scipy.special import logsumexp\nfrom scipy.spatial.distance import cdist\n\nfrom prml.markov.state_"
},
{
"path": "prml/markov/state_space_model.py",
"chars": 95,
"preview": "class StateSpaceModel(object):\n \"\"\"\n Base class for state-space models\n \"\"\"\n\n pass\n"
},
{
"path": "prml/nn/__init__.py",
"chars": 1231,
"preview": "# flake8: noqa\n\nfrom prml.nn.config import config\nfrom prml.nn.network import Network\nfrom prml.nn import array\nfrom prm"
},
{
"path": "prml/nn/array/__init__.py",
"chars": 205,
"preview": "# flake8: noqa\n\nfrom prml.nn.array.array import Array, array, asarray\nfrom prml.nn.array.reshape import reshape_method\nf"
},
{
"path": "prml/nn/array/array.py",
"chars": 3288,
"preview": "import numpy as np\n\nfrom prml.nn.config import config\nfrom prml.nn.queue import backprop_queue\n\n\nclass Array(object):\n "
},
{
"path": "prml/nn/array/broadcast.py",
"chars": 71,
"preview": "from prml.nn.function import Function, broadcast, broadcast_to # noqa\n"
},
{
"path": "prml/nn/array/ones.py",
"chars": 162,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import Array\nfrom prml.nn.config import config\n\n\ndef ones(size):\n return"
},
{
"path": "prml/nn/array/reshape.py",
"chars": 387,
"preview": "from prml.nn.function import Function\n\n\nclass Reshape(Function):\n\n @staticmethod\n def _forward(x, shape):\n "
},
{
"path": "prml/nn/array/zeros.py",
"chars": 164,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import Array\nfrom prml.nn.config import config\n\n\ndef zeros(size):\n retur"
},
{
"path": "prml/nn/config.py",
"chars": 889,
"preview": "import numpy as np\n\n\nclass Config(object):\n __dtype = np.float32\n __is_updating_bn = False\n __available_dtypes "
},
{
"path": "prml/nn/distribution/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "prml/nn/distribution/bernoulli.py",
"chars": 1295,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import asarray\nfrom prml.nn.distribution.distribution import Distribution\nf"
},
{
"path": "prml/nn/distribution/categorical.py",
"chars": 2545,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import asarray\nfrom prml.nn.distribution.distribution import Distribution\nf"
},
{
"path": "prml/nn/distribution/distribution.py",
"chars": 795,
"preview": "from prml.nn.function import Function\n\n\nclass Distribution(Function):\n is_categorical = False\n\n def __init__(self,"
},
{
"path": "prml/nn/distribution/gaussian.py",
"chars": 1993,
"preview": "import numpy as np\nimport scipy.special as sp\nfrom prml.nn.array.array import asarray\nfrom prml.nn.distribution.distribu"
},
{
"path": "prml/nn/function.py",
"chars": 2905,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import Array, asarray\nfrom prml.nn.config import config\nfrom prml.nn.queue "
},
{
"path": "prml/nn/image/__init__.py",
"chars": 248,
"preview": "# flake8: noqa\n\nfrom prml.nn.image.convolve2d import convolve2d, Convolve2d\nfrom prml.nn.image.deconvolve2d import decon"
},
{
"path": "prml/nn/image/convolve2d.py",
"chars": 2927,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import Array\nfrom prml.nn.network import Network\nfrom prml.nn.function impo"
},
{
"path": "prml/nn/image/deconvolve2d.py",
"chars": 3716,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import Array\nfrom prml.nn.function import Function\nfrom prml.nn.network imp"
},
{
"path": "prml/nn/image/max_pooling2d.py",
"chars": 3218,
"preview": "import numpy as np\n\nfrom prml.nn.config import config\nfrom prml.nn.function import Function\nfrom prml.nn.image.util impo"
},
{
"path": "prml/nn/image/util.py",
"chars": 2514,
"preview": "import itertools\n\nimport numpy as np\nfrom numpy.lib.stride_tricks import as_strided\n\n\ndef img2patch(img, size, step=1):\n"
},
{
"path": "prml/nn/io/__init__.py",
"chars": 99,
"preview": "# flake8: noqa\n\nfrom prml.nn.io.io import save_parameter, load_parameter, save_object, load_object\n"
},
{
"path": "prml/nn/io/io.py",
"chars": 569,
"preview": "import pickle\nimport numpy as np\n\n\ndef save_parameter(filename: str, parameter: dict):\n dict_ = {key: param.value for"
},
{
"path": "prml/nn/loss/__init__.py",
"chars": 321,
"preview": "from prml.nn.loss.kl import kl_divergence\nfrom prml.nn.loss.sigmoid_cross_entropy import sigmoid_cross_entropy\nfrom prml"
},
{
"path": "prml/nn/loss/kl.py",
"chars": 1433,
"preview": "from prml.nn.distribution.bernoulli import Bernoulli\nfrom prml.nn.distribution.categorical import Categorical\nfrom prml."
},
{
"path": "prml/nn/loss/sigmoid_cross_entropy.py",
"chars": 493,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass SigmoidCrossEntropy(Function):\n enable_auto_broadca"
},
{
"path": "prml/nn/loss/softmax_cross_entropy.py",
"chars": 503,
"preview": "import numpy as np\nfrom scipy.special import logsumexp\n\nfrom prml.nn.function import Function\n\n\nclass SoftmaxCrossEntrop"
},
{
"path": "prml/nn/math/__init__.py",
"chars": 775,
"preview": "from prml.nn.math.negative import negative\nfrom prml.nn.math.add import add\nfrom prml.nn.math.subtract import subtract, "
},
{
"path": "prml/nn/math/add.py",
"chars": 1280,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Add(Function):\n enable_auto_broadcast = True\n\n @"
},
{
"path": "prml/nn/math/divide.py",
"chars": 401,
"preview": "from prml.nn.function import Function\n\n\nclass Divide(Function):\n enable_auto_broadcast = True\n\n @staticmethod\n "
},
{
"path": "prml/nn/math/exp.py",
"chars": 281,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Exp(Function):\n\n def _forward(self, x):\n sel"
},
{
"path": "prml/nn/math/log.py",
"chars": 261,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Log(Function):\n\n @staticmethod\n def _forward(x):"
},
{
"path": "prml/nn/math/matmul.py",
"chars": 360,
"preview": "from prml.nn.function import Function\n\n\nclass Matmul(Function):\n\n @staticmethod\n def _forward(x, y):\n retur"
},
{
"path": "prml/nn/math/mean.py",
"chars": 583,
"preview": "from prml.nn.math.sum import sum\n\n\ndef mean(x, axis=None, keepdims=False):\n \"\"\"\n returns arithmetic mean of the el"
},
{
"path": "prml/nn/math/multiply.py",
"chars": 340,
"preview": "from prml.nn.function import Function\n\n\nclass Multiply(Function):\n enable_auto_broadcast = True\n\n @staticmethod\n "
},
{
"path": "prml/nn/math/negative.py",
"chars": 246,
"preview": "from prml.nn.function import Function\n\n\nclass Negative(Function):\n\n @staticmethod\n def _forward(x):\n return"
},
{
"path": "prml/nn/math/power.py",
"chars": 637,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Power(Function):\n \"\"\"\n First array elements rais"
},
{
"path": "prml/nn/math/product.py",
"chars": 1222,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Product(Function):\n\n def __init__(self, axis=None, "
},
{
"path": "prml/nn/math/sqrt.py",
"chars": 291,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Sqrt(Function):\n\n def _forward(self, x):\n se"
},
{
"path": "prml/nn/math/square.py",
"chars": 277,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Square(Function):\n\n @staticmethod\n def _forward("
},
{
"path": "prml/nn/math/subtract.py",
"chars": 441,
"preview": "from prml.nn.function import Function\n\n\nclass Subtract(Function):\n \"\"\"Subtraction function.\"\"\"\n\n enable_auto_broad"
},
{
"path": "prml/nn/math/sum.py",
"chars": 1534,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass SumAxisOrKeepdims(Function):\n \"\"\"\n summation alo"
},
{
"path": "prml/nn/network.py",
"chars": 1109,
"preview": "from contextlib import contextmanager\nfrom prml.nn.array.array import Array\n\n\nclass Network(object):\n\n def __init__(s"
},
{
"path": "prml/nn/nonlinear/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "prml/nn/nonlinear/log_softmax.py",
"chars": 546,
"preview": "import numpy as np\nfrom scipy.special import logsumexp\n\nfrom prml.nn.function import Function\n\n\nclass LogSoftmax(Functio"
},
{
"path": "prml/nn/nonlinear/logit.py",
"chars": 293,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Logit(Function):\n\n @staticmethod\n def _forward(x"
},
{
"path": "prml/nn/nonlinear/relu.py",
"chars": 254,
"preview": "from prml.nn.function import Function\n\n\nclass ReLU(Function):\n\n @staticmethod\n def _forward(x):\n return x.c"
},
{
"path": "prml/nn/nonlinear/sigmoid.py",
"chars": 320,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Sigmoid(Function):\n\n def _forward(self, x):\n "
},
{
"path": "prml/nn/nonlinear/softmax.py",
"chars": 442,
"preview": "import numpy as np\nfrom scipy.special import logsumexp\nfrom prml.nn.function import Function\n\n\nclass Softmax(Function):\n"
},
{
"path": "prml/nn/nonlinear/softplus.py",
"chars": 383,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Softplus(Function):\n\n @staticmethod\n def _forwar"
},
{
"path": "prml/nn/nonlinear/tanh.py",
"chars": 303,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass Tanh(Function):\n\n def _forward(self, x):\n se"
},
{
"path": "prml/nn/normalization/__init__.py",
"chars": 108,
"preview": "from prml.nn.normalization.batch_normalization import BatchNormalization\n\n\n__all__ = ['BatchNormalization']\n"
},
{
"path": "prml/nn/normalization/batch_normalization.py",
"chars": 2057,
"preview": "import numpy as np\n\nfrom prml.nn.array.ones import ones\nfrom prml.nn.array.zeros import zeros\nfrom prml.nn.config import"
},
{
"path": "prml/nn/optimizer/__init__.py",
"chars": 294,
"preview": "# flake8: noqa\n\nfrom prml.nn.optimizer.ada_delta import AdaDelta\nfrom prml.nn.optimizer.ada_grad import AdaGrad\nfrom prm"
},
{
"path": "prml/nn/optimizer/ada_delta.py",
"chars": 1175,
"preview": "import numpy as np\n\nfrom prml.nn.config import config\nfrom prml.nn.optimizer.optimizer import Optimizer\n\n\nclass AdaDelta"
},
{
"path": "prml/nn/optimizer/ada_grad.py",
"chars": 953,
"preview": "import numpy as np\n\nfrom prml.nn.config import config\nfrom prml.nn.optimizer.optimizer import Optimizer\n\n\nclass AdaGrad("
},
{
"path": "prml/nn/optimizer/adam.py",
"chars": 2289,
"preview": "import numpy as np\n\nfrom prml.nn.config import config\nfrom prml.nn.optimizer.optimizer import Optimizer\n\n\nclass Adam(Opt"
},
{
"path": "prml/nn/optimizer/gradient.py",
"chars": 314,
"preview": "from prml.nn.optimizer.optimizer import Optimizer\n\n\nclass Gradient(Optimizer):\n\n def __init__(self, parameter, learni"
},
{
"path": "prml/nn/optimizer/momentum.py",
"chars": 682,
"preview": "import numpy as np\n\nfrom prml.nn.optimizer.optimizer import Optimizer\n\n\nclass Momentum(Optimizer):\n\n def __init__(sel"
},
{
"path": "prml/nn/optimizer/optimizer.py",
"chars": 874,
"preview": "class Optimizer(object):\n\n def __init__(self, parameter: dict, learning_rate: float):\n if isinstance(parameter"
},
{
"path": "prml/nn/optimizer/rmsprop.py",
"chars": 751,
"preview": "import numpy as np\n\nfrom prml.nn.optimizer.optimizer import Optimizer\n\n\nclass RMSProp(Optimizer):\n\n def __init__(self"
},
{
"path": "prml/nn/queue.py",
"chars": 652,
"preview": "class BackPropQueue(object):\n\n def __init__(self):\n self.queue = []\n\n def __len__(self):\n return len"
},
{
"path": "prml/nn/random/__init__.py",
"chars": 258,
"preview": "from prml.nn.random.dropout import dropout\nfrom prml.nn.random.normal import normal, truncnormal\nfrom prml.nn.random.uni"
},
{
"path": "prml/nn/random/dropout.py",
"chars": 455,
"preview": "import numpy as np\n\nfrom prml.nn.function import Function\n\n\nclass DropoutFunction(Function):\n\n def _forward(self, x, "
},
{
"path": "prml/nn/random/normal.py",
"chars": 416,
"preview": "import numpy as np\nfrom scipy.stats import truncnorm\n\nfrom prml.nn.array.array import asarray\n\n\ndef normal(mean, std, si"
},
{
"path": "prml/nn/random/random.py",
"chars": 1157,
"preview": "from prml.nn.function import Function\n\n\nclass RandomVariable(Function):\n\n def __init__(self, data=None, p=None):\n "
},
{
"path": "prml/nn/random/uniform.py",
"chars": 149,
"preview": "import numpy as np\n\nfrom prml.nn.array.array import asarray\n\n\ndef uniform(min_, max_, size):\n return asarray(np.rando"
},
{
"path": "prml/preprocess/__init__.py",
"chars": 339,
"preview": "from prml.preprocess.gaussian import GaussianFeature\nfrom prml.preprocess.label_transformer import LabelTransformer\nfrom"
},
{
"path": "prml/preprocess/gaussian.py",
"chars": 1402,
"preview": "import numpy as np\n\n\nclass GaussianFeature(object):\n \"\"\"\n Gaussian feature\n\n gaussian function = exp(-0.5 * (x "
},
{
"path": "prml/preprocess/label_transformer.py",
"chars": 1390,
"preview": "import numpy as np\n\n\nclass LabelTransformer(object):\n \"\"\"\n Label encoder decoder\n\n Attributes\n ----------\n "
},
{
"path": "prml/preprocess/polynomial.py",
"chars": 1324,
"preview": "import itertools\nimport functools\nimport numpy as np\n\n\nclass PolynomialFeature(object):\n \"\"\"\n polynomial features\n"
},
{
"path": "prml/preprocess/sigmoidal.py",
"chars": 1661,
"preview": "import numpy as np\n\n\nclass SigmoidalFeature(object):\n \"\"\"Sigmoidal features.\n\n 1 / (1 + exp((m - x) @ c)\n \"\"\"\n\n"
},
{
"path": "prml/rv/__init__.py",
"chars": 835,
"preview": "from prml.rv.bernoulli import Bernoulli\nfrom prml.rv.bernoulli_mixture import BernoulliMixture\nfrom prml.rv.beta import "
},
{
"path": "prml/rv/bernoulli.py",
"chars": 3720,
"preview": "import numpy as np\n\nfrom prml.rv.rv import RandomVariable\nfrom prml.rv.beta import Beta\n\n\nclass Bernoulli(RandomVariable"
},
{
"path": "prml/rv/bernoulli_mixture.py",
"chars": 3446,
"preview": "import numpy as np\nfrom scipy.special import logsumexp\nfrom prml.rv.rv import RandomVariable\n\n\nclass BernoulliMixture(Ra"
},
{
"path": "prml/rv/beta.py",
"chars": 2004,
"preview": "import numpy as np\nfrom scipy.special import gamma\nfrom prml.rv.rv import RandomVariable\n\n\nnp.seterr(all=\"ignore\")\n\n\ncla"
},
{
"path": "prml/rv/categorical.py",
"chars": 2819,
"preview": "import numpy as np\n\nfrom prml.rv.dirichlet import Dirichlet\nfrom prml.rv.rv import RandomVariable\n\n\nclass Categorical(Ra"
},
{
"path": "prml/rv/dirichlet.py",
"chars": 1346,
"preview": "import numpy as np\nfrom scipy.special import gamma\nfrom prml.rv.rv import RandomVariable\n\n\nclass Dirichlet(RandomVariabl"
},
{
"path": "prml/rv/gamma.py",
"chars": 2369,
"preview": "import numpy as np\nfrom scipy.special import gamma\nfrom prml.rv.rv import RandomVariable\n\n\nnp.seterr(all=\"ignore\")\n\n\ncla"
},
{
"path": "prml/rv/gaussian.py",
"chars": 5277,
"preview": "import numpy as np\n\nfrom prml.rv.rv import RandomVariable\nfrom prml.rv.gamma import Gamma\n\n\nclass Gaussian(RandomVariabl"
},
{
"path": "prml/rv/multivariate_gaussian.py",
"chars": 2485,
"preview": "import numpy as np\n\nfrom prml.rv.rv import RandomVariable\n\n\nclass MultivariateGaussian(RandomVariable):\n \"\"\"\n The "
},
{
"path": "prml/rv/multivariate_gaussian_mixture.py",
"chars": 6375,
"preview": "import numpy as np\n\nfrom prml.clustering import KMeans\nfrom prml.rv.rv import RandomVariable\n\n\nclass MultivariateGaussia"
},
{
"path": "prml/rv/rv.py",
"chars": 3864,
"preview": "import numpy as np\n\n\nclass RandomVariable(object):\n \"\"\"Base class for random variables.\"\"\"\n\n def __init__(self):\n "
},
{
"path": "prml/rv/students_t.py",
"chars": 3619,
"preview": "import numpy as np\nfrom scipy.special import gamma, digamma\nfrom prml.rv.rv import RandomVariable\n\n\nclass StudentsT(Rand"
},
{
"path": "prml/rv/uniform.py",
"chars": 1983,
"preview": "import numpy as np\n\nfrom prml.rv.rv import RandomVariable\n\n\nclass Uniform(RandomVariable):\n \"\"\"Random variable that f"
},
{
"path": "prml/rv/variational_gaussian_mixture.py",
"chars": 6207,
"preview": "import numpy as np\nfrom scipy.special import digamma, gamma, logsumexp\n\nfrom prml.rv.rv import RandomVariable\n\n\nclass Va"
},
{
"path": "prml/sampling/__init__.py",
"chars": 309,
"preview": "from prml.sampling.metropolis import metropolis\nfrom prml.sampling.metropolis_hastings import metropolis_hastings\nfrom p"
},
{
"path": "prml/sampling/metropolis.py",
"chars": 876,
"preview": "import random\n\nimport numpy as np\n\n\ndef metropolis(func, rv, n, downsample=1):\n \"\"\"Metropolis algorithm.\n\n Paramet"
},
{
"path": "prml/sampling/metropolis_hastings.py",
"chars": 906,
"preview": "import random\n\nimport numpy as np\n\n\ndef metropolis_hastings(func, rv, n, downsample=1):\n \"\"\"\n Metropolis Hastings "
},
{
"path": "prml/sampling/rejection_sampling.py",
"chars": 938,
"preview": "import random\nimport numpy as np\n\n\ndef rejection_sampling(func, rv, k, n):\n \"\"\"\n perform rejection sampling n time"
},
{
"path": "prml/sampling/sir.py",
"chars": 778,
"preview": "import numpy as np\n\n\ndef sir(func, rv, n):\n \"\"\"\n sampling-importance-resampling\n\n Parameters\n ----------\n "
},
{
"path": "setup.cfg",
"chars": 2937,
"preview": "; See:\n; https://setuptools.readthedocs.io/en/latest/userguide/declarative_config.html\n\n[options.extras_require]\ndevelop"
},
{
"path": "setup.py",
"chars": 479,
"preview": "\"\"\"PRML setup module.\n\nSee:\nhttps://packaging.python.org/guides/distributing-packages-using-setuptools/\nhttps://github.c"
},
{
"path": "test/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_bayesnet/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_bayesnet/test_discrete.py",
"chars": 2793,
"preview": "import unittest\n\nimport numpy as np\n\nfrom prml import bayesnet as bn\n\n\nclass TestDiscrete(unittest.TestCase):\n\n def t"
},
{
"path": "test/test_linear/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_linear/test_bayesian_regression.py",
"chars": 650,
"preview": "import unittest\n\nimport numpy as np\n\nfrom prml.linear import BayesianRegression\n\n\nclass TestBayesianRegression(unittest."
},
{
"path": "test/test_linear/test_linear_regression.py",
"chars": 753,
"preview": "import unittest\n\nimport numpy as np\n\nfrom prml.linear import LinearRegression\n\n\nclass TestLinearRegression(unittest.Test"
},
{
"path": "test/test_linear/test_logistic_regression.py",
"chars": 720,
"preview": "import unittest\n\nimport numpy as np\n\nfrom prml.linear import LogisticRegression\n\n\nclass TestLogisticRegression(unittest."
},
{
"path": "test/test_linear/test_ridge_regression.py",
"chars": 552,
"preview": "import unittest\n\nimport numpy as np\n\nfrom prml.linear import RidgeRegression\n\n\nclass TestRidgeRegression(unittest.TestCa"
},
{
"path": "test/test_nn/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_nn/test_backward.py",
"chars": 1693,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestBackward(unittest.TestCase):\n\n def test_backwar"
},
{
"path": "test/test_nn/test_distribution/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_nn/test_distribution/test_bernoulli.py",
"chars": 1487,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestBernoulli(unittest.TestCase):\n\n def test_bernou"
},
{
"path": "test/test_nn/test_distribution/test_gaussian.py",
"chars": 1174,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestGaussian(unittest.TestCase):\n\n def test_gaussia"
},
{
"path": "test/test_nn/test_image/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_nn/test_image/test_convolve2d.py",
"chars": 1960,
"preview": "import unittest\n\nimport numpy as np\nfrom scipy.ndimage.filters import correlate\nimport prml.nn as nn\n\n\nclass TestConvolv"
},
{
"path": "test/test_nn/test_image/test_deconvolve2d.py",
"chars": 1194,
"preview": "import unittest\n\nimport numpy as np\nfrom scipy.ndimage.filters import correlate\n\nimport prml.nn as nn\n\n\nclass TestDeconv"
},
{
"path": "test/test_nn/test_image/test_max_pooling2d.py",
"chars": 874,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestMaxPooling2d(unittest.TestCase):\n\n def test_max"
},
{
"path": "test/test_nn/test_loss/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_nn/test_loss/test_sigmoid_cross_entropy.py",
"chars": 741,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestSigmoidCrossEntropy(unittest.TestCase):\n\n def t"
},
{
"path": "test/test_nn/test_math/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_nn/test_math/test_add.py",
"chars": 1345,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestAdd(unittest.TestCase):\n\n def test_add(self):\n "
},
{
"path": "test/test_nn/test_math/test_log.py",
"chars": 467,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestLog(unittest.TestCase):\n\n def test_log(self):\n "
},
{
"path": "test/test_nn/test_math/test_matmul.py",
"chars": 580,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestMatmul(unittest.TestCase):\n\n def test_matmul(se"
},
{
"path": "test/test_nn/test_math/test_multiply.py",
"chars": 1383,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestMultiply(unittest.TestCase):\n\n def test_multipl"
},
{
"path": "test/test_nn/test_math/test_negative.py",
"chars": 421,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestNegative(unittest.TestCase):\n\n def test_negativ"
},
{
"path": "test/test_nn/test_nonlinear/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "test/test_nn/test_nonlinear/test_log_softmax.py",
"chars": 669,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestLogSoftmax(unittest.TestCase):\n\n def test_forwa"
},
{
"path": "test/test_nn/test_nonlinear/test_sigmoid.py",
"chars": 481,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestSigmoid(unittest.TestCase):\n\n def test_sigmoid("
},
{
"path": "test/test_nn/test_nonlinear/test_softmax.py",
"chars": 759,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestSoftmax(unittest.TestCase):\n\n def test_forward("
},
{
"path": "test/test_nn/test_nonlinear/test_tanh.py",
"chars": 449,
"preview": "import unittest\n\nimport numpy as np\n\nimport prml.nn as nn\n\n\nclass TestTanh(unittest.TestCase):\n\n def test_tanh(self):"
},
{
"path": "test/test_nn/test_random/__init__.py",
"chars": 0,
"preview": ""
}
]
About this extraction
This page contains the full source code of the ctgk/PRML GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 184 files (3.7 MB), approximately 973.4k tokens, and a symbol index with 720 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.