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):