Create a random real-valued tensor of shape `shape`. If `standardize` is True, ensure each column has mean 0 and std 1.

Compute the gradient of the VLB with regard to the network parameters. Parameters ---------- y : :py:class:`ndarray

The activation function for the base layer.

A Restricted Boltzmann machine with Bernoulli visible and hidden units. Parameters ---------- n_out : int

Use the trained decision tree to classify or predict the examples in `X`. Parameters ---------- X : :py:class:`ndarr

Fit a binary decision tree to a dataset. Parameters ---------- X : :py:class:`ndarray <numpy.ndarray>` of shape `(N,

Zero-pad a 4D input volume `X` along the second and third dimensions. Parameters ---------- X : :py:class:`ndarray <numpy.ndarray>`

r""" An exponential linear unit (ELU). Notes ----- ELUs are intended to address the fact that ReLUs are strictly nonn

Return a copy of the current object.

Redefine scipy.special.logsumexp see: http://bayesjumping.net/log-sum-exp-trick/

Reset the bandit step and action counters to zero.

Return a dictionary of the gradients computed during the backward pass

r""" Generate predictions for the targets associated with the rows in `X`. Parameters ---------- X : numpy array of s

Use the trained model to generate predictions on a new collection of data points. Parameters ---------- X :

Train the LDA model on a corpus of documents (bags of words). Parameters ---------- corpus : list of length `D`

Create a random stochastic matrix of shape (`n_examples`, `n_classes`)

Increment the optimizer step counter by 1

r""" Evaluate the ELU activation on the elements of input `z`. .. math:: \text{ELU}(z_i) &= z_i \ \ \ \

r""" Fit regression coefficients via maximum likelihood. Parameters ---------- X : :py:class:`ndarray <numpy.ndarray>

Erase all the layer's derived variables and gradients.

Check that a value `a` is numeric

Remove the item with the largest/smallest (depending on ``self.heap_order``) priority from the queue and return it. Notes

Compute the padding necessary to ensure that convolving `X` with a 2D kernel of shape `kernel_shape` and stride `stride` produces outputs wit

Encode a collection of multi-featured examples into a `n_dim`-dimensional feature matrix via feature hashing. Notes

r""" Fit the model to the data and targets in `X` and `y` Parameters ---------- X : numpy array of shape `(N, M)`

Zero-pad a 3D input volume `X` along the second dimension. Parameters ---------- X : :py:class:`ndarray <numpy.ndarray>` of shape `(

r""" Update the agent parameters according to the rewards accrued on the current episode. Returns ------- avg

The variational lower bound for a variational autoencoder with Bernoulli units. Notes ----- The VLB to the s

Clear the episode history

Perform the CD-`k` "forward pass" of visible inputs into hidden units and back. Notes ----- This implementat

Return the internal indices of the vertices reachable from the vertex with index `v_i`.

Split a string into individual words, optionally removing punctuation and stop-words in the process.

Update the layer parameters using the accrued gradients and layer optimizer. Flush all gradients once the update is complete.

Abstract base class for all Scheduler objects.

r""" A UCB1 policy for multi-armed bandit problems. Notes ----- The UCB1 algorithm [*]_ guarantees the cumulative reg

Perform a gradient update on the layer parameters via the contrastive divergence equations. Parameters ----------

Compute the fan-in and fan-out for a weight matrix/volume. Parameters ---------- weight_shape : tuple The dimensions of the

A faster (but more memory intensive) implementation of the 2D "convolution" (technically, cross-correlation) of input `X` with a collection o

E[log X_t] where X_t ~ Dir

Filter (or replace) any word in `words` that is not present in `Vocabulary`. Parameters ---------- words : l

r""" Evaluate the logistic sigmoid, :math:`\sigma`, on the elements of input `z`. .. math:: \sigma(x_i) = \frac{1}{1 + e

Perform the forward pass for either the generator or the critic. Parameters ---------- X : :py:class:`ndarray <numpy

Pads and rearrange overlapping windows of the input volume into column vectors, returning the concatenated padded vectors in a matrix `X_col`

r""" Compute the smoothed log probability of a sequence of words under the `N`-gram language model with additive smoothing. N

Variational lower bound for a Bernoulli VAE. Parameters ---------- y : :py:class:`ndarray <numpy.ndarray>` of shape

Return all `N`-grams of the elements in `sequence`

A wrapper for `tf.Variable` which enables parameter sharing in models. Creates and returns theano shared variables similarly to `tf.Variable

Return the MAP estimate for :math:`y^*`, corresponding the mean/mode of the posterior predictive distribution, :math:`p(y^* \mid x^*,

Generate predictions for the targets associated with the rows in `X`. Parameters ---------- X : :py:class:`ndarray <

Return the MAP prediction for the targets associated with `X`. Parameters ---------- X : :py:class:`ndarray <numpy.n

Return the MAP prediction for the targets associated with `X`. Parameters ---------- X : :py:class:`ndarray <numpy.n

Predict the target value for each entry in `X`. Parameters ---------- X : :py:class:`ndarray <numpy.ndarray>` of sha

Use the trained model to classify or predict the examples in `X`. Parameters ---------- X : :py:class:`ndarray <nump

Create a random one-hot matrix of shape (`n_examples`, `n_classes`)

Generate a random paragraph consisting of `n_words` words. If `vocab` is not None, words will be drawn at random from this list. Otherwise, w

Generate an unweighted Erdős-Rényi random graph [*]_. References ---------- .. [*] Erdős, P. and Rényi, A. (1959). On Random Graphs,

Sample functions from the GP prior or posterior predictive distribution. Parameters ---------- X : :py:class

Convert my graph representation to a networkx graph

Train an agent on an OpenAI gym environment, logging training statistics along the way. Parameters ----------

Perform gradient updates and flush gradients upon completion

A stochastic gradient descent optimizer. Notes ----- For model parameters :math:`\\theta`, averaged parameter gradie

Radial basis function (RBF) / squared exponential kernel. Notes ----- For input vectors :math:`\mathbf{x}` and :math

A simple, unsmoothed N-gram model. Parameters ---------- N : int The maximum length (in words) of the co

Calculate the log probability of a sequence of words under the `N`-gram model

Perform the backward pass for either the generator or the critic. Parameters ---------- grad : :py:class:`ndarray <n

Take columns of a 2D matrix and rearrange them into the blocks/windows of a 4D image volume. Notes ----- A NumPy reimagining of

Fit the GP prior to the training data. Parameters ---------- X : :py:class:`ndarray <numpy.ndarray>` of shape `(N, M

Fit the regression model to the data and targets in `X` and `y`. Parameters ---------- X : :py:class:`ndarray <numpy

Compute the vocabulary across a collection of documents. Parameters ---------- corpus_fps : str or list of strs

Reset parameter gradients to 0 after an update.

r""" Compute the GELU function on the elements of input `z`. .. math:: \text{GELU}(z_i) = z_i P(Z \leq z_i) = z_i \Phi(z

Compute the layer output on a single minibatch. Parameters ---------- X : :py:class:`ndarray <numpy.ndarray>` of sha

The generalized cosine family of window functions. Notes ----- The generalized cosine window is a simple weighted sum of cosine term

r""" Evaluate the first derivative of the GELU function on the elements of input `x`. .. math:: \frac{\partial \

r""" Evaluate the second derivative of the ELU activation on the elements of input `x`. .. math:: \frac{\partial

Compute log N(x_i | mu, sigma)

r""" Given the HMM parameterized by :math:`(A`, B, \pi)` and an observation sequence `O`, compute the marginal likelihood of `O`,

Compute the log probability of a sequence of words under the unsmoothed, maximum-likelihood `N`-gram language model. Paramet

r""" Compute the smoothed log probability of a sequence of words under the `N`-gram language model with Good-Turing smoothing.

Compute the squared error between `y` and `y_pred`. Parameters ---------- y : :py:class:`ndarray <numpy.ndarray>` of