SYMBOL INDEX (428 symbols across 54 files)

FILE: examples/gaussian_mixture.py
  function make_clusters (line 12) | def make_clusters(skew=True, *arg, **kwargs):
  function KMeans_and_GMM (line 21) | def KMeans_and_GMM(K):

FILE: examples/gbm.py
  function classification (line 18) | def classification():
  function regression (line 44) | def regression():

FILE: examples/kmeans.py
  function kmeans_example (line 7) | def kmeans_example(plot=False):

FILE: examples/linear_models.py
  function regression (line 17) | def regression():
  function classification (line 38) | def classification():

FILE: examples/naive_bayes.py
  function classification (line 8) | def classification():

FILE: examples/nearest_neighbors.py
  function regression (line 13) | def regression():
  function classification (line 34) | def classification():

FILE: examples/nnet_mlp.py
  function classification (line 23) | def classification():
  function regression (line 59) | def regression():

FILE: examples/nnet_rnn_binary_add.py
  function addition_dataset (line 20) | def addition_dataset(dim=10, n_samples=10000, batch_size=64):
  function addition_problem (line 56) | def addition_problem(ReccurentLayer):

FILE: examples/nnet_rnn_text_generation.py
  function sample (line 22) | def sample(preds, temperature=1.0):

FILE: examples/random_forest.py
  function classification (line 19) | def classification():
  function regression (line 45) | def regression():

FILE: examples/rbm.py
  function print_curve (line 10) | def print_curve(rbm):

FILE: examples/rl_deep_q_learning.py
  function mlp_model (line 11) | def mlp_model(n_actions, batch_size=64):

FILE: examples/svm.py
  function classification (line 16) | def classification():

FILE: mla/base/base.py
  class BaseEstimator (line 5) | class BaseEstimator:
    method _setup_input (line 9) | def _setup_input(self, X, y=None):
    method fit (line 50) | def fit(self, X, y=None):
    method predict (line 53) | def predict(self, X=None):
    method _predict (line 62) | def _predict(self, X=None):

FILE: mla/datasets/base.py
  function get_filename (line 7) | def get_filename(name):
  function load_mnist (line 11) | def load_mnist():
  function load_nietzsche (line 58) | def load_nietzsche():

FILE: mla/ensemble/base.py
  function f_entropy (line 6) | def f_entropy(p):
  function information_gain (line 16) | def information_gain(y, splits):
  function mse_criterion (line 23) | def mse_criterion(y, splits):
  function xgb_criterion (line 33) | def xgb_criterion(y, left, right, loss):
  function get_split_mask (line 41) | def get_split_mask(X, column, value):
  function split (line 47) | def split(X, y, value):
  function split_dataset (line 53) | def split_dataset(X, target, column, value, return_X=True):

FILE: mla/ensemble/gbm.py
  class Loss (line 20) | class Loss:
    method __init__ (line 23) | def __init__(self, regularization=1.0):
    method grad (line 26) | def grad(self, actual, predicted):
    method hess (line 30) | def hess(self, actual, predicted):
    method approximate (line 34) | def approximate(self, actual, predicted):
    method transform (line 40) | def transform(self, pred):
    method gain (line 44) | def gain(self, actual, predicted):
  class LeastSquaresLoss (line 51) | class LeastSquaresLoss(Loss):
    method grad (line 54) | def grad(self, actual, predicted):
    method hess (line 57) | def hess(self, actual, predicted):
  class LogisticLoss (line 61) | class LogisticLoss(Loss):
    method grad (line 64) | def grad(self, actual, predicted):
    method hess (line 67) | def hess(self, actual, predicted):
    method transform (line 71) | def transform(self, output):
  class GradientBoosting (line 76) | class GradientBoosting(BaseEstimator):
    method __init__ (line 79) | def __init__(
    method fit (line 95) | def fit(self, X, y=None):
    method _train (line 100) | def _train(self):
    method _predict (line 130) | def _predict(self, X=None):
    method predict (line 137) | def predict(self, X=None):
  class GradientBoostingRegressor (line 141) | class GradientBoostingRegressor(GradientBoosting):
    method fit (line 142) | def fit(self, X, y=None):
  class GradientBoostingClassifier (line 147) | class GradientBoostingClassifier(GradientBoosting):
    method fit (line 148) | def fit(self, X, y=None):

FILE: mla/ensemble/random_forest.py
  class RandomForest (line 9) | class RandomForest(BaseEstimator):
    method __init__ (line 10) | def __init__(
    method fit (line 39) | def fit(self, X, y):
    method _train (line 47) | def _train(self):
    method _predict (line 57) | def _predict(self, X=None):
  class RandomForestClassifier (line 61) | class RandomForestClassifier(RandomForest):
    method __init__ (line 62) | def __init__(
    method _predict (line 87) | def _predict(self, X=None):
  class RandomForestRegressor (line 101) | class RandomForestRegressor(RandomForest):
    method __init__ (line 102) | def __init__(
    method _predict (line 126) | def _predict(self, X=None):

FILE: mla/ensemble/tree.py
  class Tree (line 12) | class Tree(object):
    method __init__ (line 15) | def __init__(self, regression=False, criterion=None, n_classes=None):
    method is_terminal (line 29) | def is_terminal(self):
    method _find_splits (line 32) | def _find_splits(self, X):
    method _find_best_split (line 45) | def _find_best_split(self, X, target, n_features):
    method _train (line 70) | def _train(
    method train (line 126) | def train(
    method _calculate_leaf_value (line 176) | def _calculate_leaf_value(self, targets):
    method predict_row (line 193) | def predict_row(self, row):
    method predict (line 202) | def predict(self, X):

FILE: mla/fm.py
  class BaseFM (line 18) | class BaseFM(BaseEstimator):
    method __init__ (line 19) | def __init__(
    method fit (line 40) | def fit(self, X, y=None):
    method _train (line 52) | def _train(self):
    method _factor_step (line 61) | def _factor_step(self, loss):
    method _predict (line 67) | def _predict(self, X=None):
  class FMRegressor (line 75) | class FMRegressor(BaseFM):
    method fit (line 76) | def fit(self, X, y=None):
  class FMClassifier (line 82) | class FMClassifier(BaseFM):
    method fit (line 83) | def fit(self, X, y=None):
    method predict (line 88) | def predict(self, X=None):

FILE: mla/gaussian_mixture.py
  class GaussianMixture (line 13) | class GaussianMixture(BaseEstimator):
    method __init__ (line 44) | def __init__(self, K=4, init="random", max_iters=500, tolerance=1e-3):
    method fit (line 52) | def fit(self, X, y=None):
    method _initialize (line 62) | def _initialize(self):
    method _E_step (line 89) | def _E_step(self):
    method _M_step (line 98) | def _M_step(self):
    method _is_converged (line 109) | def _is_converged(self):
    method _predict (line 117) | def _predict(self, X):
    method _get_likelihood (line 126) | def _get_likelihood(self, data):
    method _get_weighted_likelihood (line 135) | def _get_weighted_likelihood(self, likelihood):
    method plot (line 138) | def plot(self, data=None, ax=None, holdon=False):

FILE: mla/kmeans.py
  class KMeans (line 15) | class KMeans(BaseEstimator):
    method __init__ (line 45) | def __init__(self, K=5, max_iters=100, init="random"):
    method _initialize_centroids (line 52) | def _initialize_centroids(self, init):
    method _predict (line 66) | def _predict(self, X=None):
    method _get_predictions (line 84) | def _get_predictions(self):
    method _assign (line 92) | def _assign(self, centroids):
    method _closest (line 102) | def _closest(self, fpoint, centroids):
    method _get_centroid (line 113) | def _get_centroid(self, cluster):
    method _dist_from_centers (line 117) | def _dist_from_centers(self):
    method _choose_next_center (line 123) | def _choose_next_center(self):
    method _is_converged (line 130) | def _is_converged(self, centroids_old, centroids):
    method plot (line 137) | def plot(self, ax=None, holdon=False):

FILE: mla/knn.py
  class KNNBase (line 11) | class KNNBase(BaseEstimator):
    method __init__ (line 12) | def __init__(self, k=5, distance_func=euclidean):
    method aggregate (line 28) | def aggregate(self, neighbors_targets):
    method _predict (line 31) | def _predict(self, X=None):
    method _predict_x (line 36) | def _predict_x(self, x):
  class KNNClassifier (line 55) | class KNNClassifier(KNNBase):
    method aggregate (line 61) | def aggregate(self, neighbors_targets):
  class KNNRegressor (line 68) | class KNNRegressor(KNNBase):
    method aggregate (line 71) | def aggregate(self, neighbors_targets):

FILE: mla/linear_models.py
  class BasicRegression (line 14) | class BasicRegression(BaseEstimator):
    method __init__ (line 15) | def __init__(
    method _loss (line 46) | def _loss(self, w):
    method init_cost (line 49) | def init_cost(self):
    method _add_penalty (line 52) | def _add_penalty(self, loss, w):
    method _cost (line 60) | def _cost(self, X, y, theta):
    method fit (line 65) | def fit(self, X, y=None):
    method _add_intercept (line 79) | def _add_intercept(X):
    method _train (line 83) | def _train(self):
    method _predict (line 87) | def _predict(self, X=None):
    method _gradient_descent (line 91) | def _gradient_descent(self):
  class LinearRegression (line 111) | class LinearRegression(BasicRegression):
    method _loss (line 114) | def _loss(self, w):
    method init_cost (line 118) | def init_cost(self):
  class LogisticRegression (line 122) | class LogisticRegression(BasicRegression):
    method init_cost (line 125) | def init_cost(self):
    method _loss (line 128) | def _loss(self, w):
    method sigmoid (line 133) | def sigmoid(x):
    method _predict (line 136) | def _predict(self, X=None):

FILE: mla/metrics/base.py
  function check_data (line 5) | def check_data(a, b):
  function validate_input (line 20) | def validate_input(function):

FILE: mla/metrics/distance.py
  function euclidean_distance (line 7) | def euclidean_distance(a, b):
  function l2_distance (line 15) | def l2_distance(X):

FILE: mla/metrics/metrics.py
  function unhot (line 7) | def unhot(function):
  function absolute_error (line 20) | def absolute_error(actual, predicted):
  function classification_error (line 25) | def classification_error(actual, predicted):
  function accuracy (line 30) | def accuracy(actual, predicted):
  function mean_absolute_error (line 34) | def mean_absolute_error(actual, predicted):
  function squared_error (line 38) | def squared_error(actual, predicted):
  function squared_log_error (line 42) | def squared_log_error(actual, predicted):
  function mean_squared_log_error (line 46) | def mean_squared_log_error(actual, predicted):
  function mean_squared_error (line 50) | def mean_squared_error(actual, predicted):
  function root_mean_squared_error (line 54) | def root_mean_squared_error(actual, predicted):
  function root_mean_squared_log_error (line 58) | def root_mean_squared_log_error(actual, predicted):
  function logloss (line 62) | def logloss(actual, predicted):
  function hinge (line 68) | def hinge(actual, predicted):
  function binary_crossentropy (line 72) | def binary_crossentropy(actual, predicted):
  function get_metric (line 85) | def get_metric(name):

FILE: mla/metrics/tests/test_metrics.py
  function test_data_validation (line 11) | def test_data_validation():
  function metric (line 24) | def metric(name):
  function test_classification_error (line 28) | def test_classification_error():
  function test_absolute_error (line 35) | def test_absolute_error():
  function test_mean_absolute_error (line 41) | def test_mean_absolute_error():
  function test_squared_error (line 47) | def test_squared_error():
  function test_squared_log_error (line 53) | def test_squared_log_error():
  function test_mean_squared_log_error (line 60) | def test_mean_squared_log_error():
  function test_root_mean_squared_log_error (line 66) | def test_root_mean_squared_log_error():
  function test_mean_squared_error (line 72) | def test_mean_squared_error():
  function test_root_mean_squared_error (line 78) | def test_root_mean_squared_error():
  function test_multiclass_logloss (line 84) | def test_multiclass_logloss():

FILE: mla/naive_bayes.py
  class NaiveBayesClassifier (line 9) | class NaiveBayesClassifier(BaseEstimator):
    method fit (line 15) | def fit(self, X, y=None):
    method _predict (line 35) | def _predict(self, X=None):
    method _predict_row (line 42) | def _predict_row(self, x):
    method _pdf (line 53) | def _pdf(self, n_class, x):

FILE: mla/neuralnet/activations.py
  function sigmoid (line 9) | def sigmoid(z):
  function softmax (line 13) | def softmax(z):
  function linear (line 19) | def linear(z):
  function softplus (line 23) | def softplus(z):
  function softsign (line 30) | def softsign(z):
  function tanh (line 34) | def tanh(z):
  function relu (line 38) | def relu(z):
  function leakyrelu (line 42) | def leakyrelu(z, a=0.01):
  function get_activation (line 46) | def get_activation(name):

FILE: mla/neuralnet/constraints.py
  class Constraint (line 7) | class Constraint(object):
    method clip (line 8) | def clip(self, p):
  class MaxNorm (line 12) | class MaxNorm(object):
    method __init__ (line 13) | def __init__(self, m=2, axis=0):
    method clip (line 17) | def clip(self, p):
  class NonNeg (line 24) | class NonNeg(object):
    method clip (line 25) | def clip(self, p):
  class SmallNorm (line 30) | class SmallNorm(object):
    method clip (line 31) | def clip(self, p):
  class UnitNorm (line 35) | class UnitNorm(Constraint):
    method __init__ (line 36) | def __init__(self, axis=0):
    method clip (line 39) | def clip(self, p):

FILE: mla/neuralnet/initializations.py
  function normal (line 10) | def normal(shape, scale=0.5):
  function uniform (line 14) | def uniform(shape, scale=0.5):
  function zero (line 18) | def zero(shape, **kwargs):
  function one (line 22) | def one(shape, **kwargs):
  function orthogonal (line 26) | def orthogonal(shape, scale=0.5):
  function _glorot_fan (line 34) | def _glorot_fan(shape):
  function glorot_normal (line 46) | def glorot_normal(shape, **kwargs):
  function glorot_uniform (line 52) | def glorot_uniform(shape, **kwargs):
  function he_normal (line 58) | def he_normal(shape, **kwargs):
  function he_uniform (line 64) | def he_uniform(shape, **kwargs):
  function get_initializer (line 70) | def get_initializer(name):

FILE: mla/neuralnet/layers/basic.py
  class Layer (line 11) | class Layer(object):
    method setup (line 12) | def setup(self, X_shape):
    method forward_pass (line 16) | def forward_pass(self, x):
    method backward_pass (line 19) | def backward_pass(self, delta):
    method shape (line 22) | def shape(self, x_shape):
  class ParamMixin (line 27) | class ParamMixin(object):
    method parameters (line 29) | def parameters(self):
  class PhaseMixin (line 33) | class PhaseMixin(object):
    method is_training (line 37) | def is_training(self):
    method is_training (line 41) | def is_training(self, is_train=True):
    method is_testing (line 45) | def is_testing(self):
    method is_testing (line 49) | def is_testing(self, is_test=True):
  class Dense (line 53) | class Dense(Layer, ParamMixin):
    method __init__ (line 54) | def __init__(self, output_dim, parameters=None):
    method setup (line 68) | def setup(self, x_shape):
    method forward_pass (line 71) | def forward_pass(self, X):
    method weight (line 75) | def weight(self, X):
    method backward_pass (line 79) | def backward_pass(self, delta):
    method shape (line 88) | def shape(self, x_shape):
  class Activation (line 92) | class Activation(Layer):
    method __init__ (line 93) | def __init__(self, name):
    method forward_pass (line 99) | def forward_pass(self, X):
    method backward_pass (line 103) | def backward_pass(self, delta):
    method shape (line 106) | def shape(self, x_shape):
  class Dropout (line 110) | class Dropout(Layer, PhaseMixin):
    method __init__ (line 113) | def __init__(self, p=0.1):
    method forward_pass (line 117) | def forward_pass(self, X):
    method backward_pass (line 127) | def backward_pass(self, delta):
    method shape (line 130) | def shape(self, x_shape):
  class TimeStepSlicer (line 134) | class TimeStepSlicer(Layer):
    method __init__ (line 137) | def __init__(self, step=-1):
    method forward_pass (line 140) | def forward_pass(self, x):
    method backward_pass (line 143) | def backward_pass(self, delta):
    method shape (line 146) | def shape(self, x_shape):
  class TimeDistributedDense (line 150) | class TimeDistributedDense(Layer):
    method __init__ (line 153) | def __init__(self, output_dim):
    method setup (line 159) | def setup(self, X_shape):
    method forward_pass (line 164) | def forward_pass(self, X):
    method backward_pass (line 171) | def backward_pass(self, delta):
    method parameters (line 179) | def parameters(self):
    method shape (line 182) | def shape(self, x_shape):

FILE: mla/neuralnet/layers/convnet.py
  class Convolution (line 8) | class Convolution(Layer, ParamMixin):
    method __init__ (line 9) | def __init__(
    method setup (line 41) | def setup(self, X_shape):
    method forward_pass (line 48) | def forward_pass(self, X):
    method backward_pass (line 58) | def backward_pass(self, delta):
    method shape (line 71) | def shape(self, x_shape):
  class MaxPooling (line 78) | class MaxPooling(Layer):
    method __init__ (line 79) | def __init__(self, pool_shape=(2, 2), stride=(1, 1), padding=(0, 0)):
    method forward_pass (line 93) | def forward_pass(self, X):
    method backward_pass (line 109) | def backward_pass(self, delta):
    method shape (line 122) | def shape(self, x_shape):
  class Flatten (line 129) | class Flatten(Layer):
    method forward_pass (line 132) | def forward_pass(self, X):
    method backward_pass (line 136) | def backward_pass(self, delta):
    method shape (line 139) | def shape(self, x_shape):
  function image_to_column (line 143) | def image_to_column(images, filter_shape, stride, padding):
  function column_to_image (line 175) | def column_to_image(columns, images_shape, filter_shape, stride, padding):
  function convoltuion_shape (line 210) | def convoltuion_shape(img_height, img_width, filter_shape, stride, paddi...
  function pooling_shape (line 221) | def pooling_shape(pool_shape, image_shape, stride):

FILE: mla/neuralnet/layers/normalization.py
  class BatchNormalization (line 13) | class BatchNormalization(Layer, ParamMixin, PhaseMixin):
    method __init__ (line 14) | def __init__(self, momentum=0.9, eps=1e-5, parameters=None):
    method setup (line 24) | def setup(self, x_shape):
    method _forward_pass (line 27) | def _forward_pass(self, X):
    method forward_pass (line 82) | def forward_pass(self, X):
    method _backward_pass (line 97) | def _backward_pass(self, delta):
    method backward_pass (line 144) | def backward_pass(self, X):
    method shape (line 157) | def shape(self, x_shape):

FILE: mla/neuralnet/layers/recurrent/lstm.py
  class LSTM (line 17) | class LSTM(Layer, ParamMixin):
    method __init__ (line 18) | def __init__(
    method setup (line 47) | def setup(self, x_shape):
    method forward_pass (line 87) | def forward_pass(self, X):
    method backward_pass (line 133) | def backward_pass(self, delta):
    method shape (line 191) | def shape(self, x_shape):

FILE: mla/neuralnet/layers/recurrent/rnn.py
  class RNN (line 10) | class RNN(Layer, ParamMixin):
    method __init__ (line 13) | def __init__(
    method setup (line 35) | def setup(self, x_shape):
    method forward_pass (line 55) | def forward_pass(self, X):
    method backward_pass (line 76) | def backward_pass(self, delta):
    method shape (line 106) | def shape(self, x_shape):

FILE: mla/neuralnet/loss.py
  function get_loss (line 6) | def get_loss(name):

FILE: mla/neuralnet/nnet.py
  class NeuralNet (line 22) | class NeuralNet(BaseEstimator):
    method __init__ (line 25) | def __init__(
    method _setup_layers (line 58) | def _setup_layers(self, x_shape):
    method _find_bprop_entry (line 73) | def _find_bprop_entry(self):
    method fit (line 80) | def fit(self, X, y=None):
    method update (line 94) | def update(self, X, y):
    method fprop (line 104) | def fprop(self, X):
    method _predict (line 110) | def _predict(self, X=None):
    method parametric_layers (line 121) | def parametric_layers(self):
    method parameters (line 127) | def parameters(self):
    method error (line 134) | def error(self, X=None, y=None):
    method is_training (line 152) | def is_training(self):
    method is_training (line 156) | def is_training(self, train):
    method shuffle_dataset (line 162) | def shuffle_dataset(self):
    method n_layers (line 171) | def n_layers(self):
    method n_params (line 176) | def n_params(self):
    method reset (line 180) | def reset(self):

FILE: mla/neuralnet/optimizers.py
  class Optimizer (line 17) | class Optimizer(object):
    method optimize (line 18) | def optimize(self, network):
    method update (line 35) | def update(self, network):
    method train_epoch (line 39) | def train_epoch(self, network):
    method train_batch (line 60) | def train_batch(self, network, X, y):
    method setup (line 65) | def setup(self, network):
  class SGD (line 71) | class SGD(Optimizer):
    method __init__ (line 72) | def __init__(self, learning_rate=0.01, momentum=0.9, decay=0.0, nester...
    method update (line 80) | def update(self, network):
    method setup (line 95) | def setup(self, network):
  class Adagrad (line 102) | class Adagrad(Optimizer):
    method __init__ (line 103) | def __init__(self, learning_rate=0.01, epsilon=1e-8):
    method update (line 107) | def update(self, network):
    method setup (line 115) | def setup(self, network):
  class Adadelta (line 123) | class Adadelta(Optimizer):
    method __init__ (line 124) | def __init__(self, learning_rate=1.0, rho=0.95, epsilon=1e-8):
    method update (line 129) | def update(self, network):
    method setup (line 148) | def setup(self, network):
  class RMSprop (line 158) | class RMSprop(Optimizer):
    method __init__ (line 159) | def __init__(self, learning_rate=0.001, rho=0.9, epsilon=1e-8):
    method update (line 164) | def update(self, network):
    method setup (line 174) | def setup(self, network):
  class Adam (line 182) | class Adam(Optimizer):
    method __init__ (line 183) | def __init__(self, learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsi...
    method update (line 191) | def update(self, network):
    method setup (line 211) | def setup(self, network):
  class Adamax (line 221) | class Adamax(Optimizer):
    method __init__ (line 222) | def __init__(self, learning_rate=0.002, beta_1=0.9, beta_2=0.999, epsi...
    method update (line 229) | def update(self, network):
    method setup (line 245) | def setup(self, network):

FILE: mla/neuralnet/parameters.py
  class Parameters (line 7) | class Parameters(object):
    method __init__ (line 8) | def __init__(
    method setup_weights (line 49) | def setup_weights(self, W_shape, b_shape=None):
    method init_grad (line 58) | def init_grad(self):
    method step (line 64) | def step(self, name, step):
    method update_grad (line 71) | def update_grad(self, name, value):
    method n_params (line 79) | def n_params(self):
    method keys (line 83) | def keys(self):
    method grad (line 87) | def grad(self):
    method __getitem__ (line 91) | def __getitem__(self, item):
    method __setitem__ (line 97) | def __setitem__(self, key, value):

FILE: mla/neuralnet/regularizers.py
  class Regularizer (line 6) | class Regularizer(object):
    method __init__ (line 7) | def __init__(self, C=0.01):
    method _penalty (line 11) | def _penalty(self, weights):
    method grad (line 14) | def grad(self, weights):
    method __call__ (line 17) | def __call__(self, weights):
  class L1 (line 21) | class L1(Regularizer):
    method _penalty (line 22) | def _penalty(self, weights):
  class L2 (line 26) | class L2(Regularizer):
    method _penalty (line 27) | def _penalty(self, weights):
  class ElasticNet (line 31) | class ElasticNet(Regularizer):
    method _penalty (line 34) | def _penalty(self, weights):

FILE: mla/neuralnet/tests/test_activations.py
  function test_softplus (line 8) | def test_softplus():

FILE: mla/neuralnet/tests/test_optimizers.py
  function clasifier (line 11) | def clasifier(optimizer):
  function test_adadelta (line 49) | def test_adadelta():
  function test_adam (line 53) | def test_adam():
  function test_adamax (line 57) | def test_adamax():
  function test_rmsprop (line 61) | def test_rmsprop():
  function test_adagrad (line 65) | def test_adagrad():
  function test_sgd (line 69) | def test_sgd():

FILE: mla/pca.py
  class PCA (line 12) | class PCA(BaseEstimator):
    method __init__ (line 15) | def __init__(self, n_components, solver="svd"):
    method fit (line 35) | def fit(self, X, y=None):
    method _decompose (line 39) | def _decompose(self, X):
    method transform (line 57) | def transform(self, X):
    method _predict (line 62) | def _predict(self, X=None):

FILE: mla/rbm.py
  class RBM (line 19) | class RBM(BaseEstimator):
    method __init__ (line 22) | def __init__(self, n_hidden=128, learning_rate=0.1, batch_size=10, max...
    method fit (line 39) | def fit(self, X, y=None):
    method _init_weights (line 45) | def _init_weights(self):
    method _train (line 54) | def _train(self):
    method _sample (line 97) | def _sample(self, X):
    method _predict (line 100) | def _predict(self, X=None):

FILE: mla/rl/dqn.py
  class DQN (line 20) | class DQN(object):
    method __init__ (line 21) | def __init__(
    method init_environment (line 55) | def init_environment(self, name="CartPole-v0", monitor=False):
    method init_model (line 68) | def init_model(self, model):
    method train (line 71) | def train(self, render=False):
    method play (line 145) | def play(self, episodes):

FILE: mla/svm/kernerls.py
  class Linear (line 6) | class Linear(object):
    method __call__ (line 7) | def __call__(self, x, y):
    method __repr__ (line 10) | def __repr__(self):
  class Poly (line 14) | class Poly(object):
    method __init__ (line 15) | def __init__(self, degree=2):
    method __call__ (line 18) | def __call__(self, x, y):
    method __repr__ (line 21) | def __repr__(self):
  class RBF (line 25) | class RBF(object):
    method __init__ (line 26) | def __init__(self, gamma=0.1):
    method __call__ (line 29) | def __call__(self, x, y):
    method __repr__ (line 34) | def __repr__(self):

FILE: mla/svm/svm.py
  class SVM (line 17) | class SVM(BaseEstimator):
    method __init__ (line 18) | def __init__(self, C=1.0, kernel=None, tol=1e-3, max_iter=100):
    method fit (line 40) | def fit(self, X, y=None):
    method _train (line 49) | def _train(self):
    method _predict (line 107) | def _predict(self, X=None):
    method _predict_row (line 114) | def _predict_row(self, X):
    method clip (line 118) | def clip(self, alpha, H, L):
    method _error (line 125) | def _error(self, i):
    method _find_bounds (line 129) | def _find_bounds(self, i, j):
    method random_index (line 141) | def random_index(self, z):

FILE: mla/tests/test_classification_accuracy.py
  function test_linear_model (line 43) | def test_linear_model():
  function test_random_forest (line 50) | def test_random_forest():
  function test_svm_classification (line 57) | def test_svm_classification():
  function test_mlp (line 68) | def test_mlp():
  function test_gbm (line 93) | def test_gbm():
  function test_naive_bayes (line 102) | def test_naive_bayes():
  function test_knn (line 109) | def test_knn():

FILE: mla/tests/test_reduction.py
  function dataset (line 16) | def dataset():
  function test_PCA (line 30) | def test_PCA(dataset):

FILE: mla/tests/test_regression_accuracy.py
  function test_linear (line 30) | def test_linear():
  function test_mlp (line 37) | def test_mlp():
  function test_knn (line 57) | def test_knn():

FILE: mla/tsne.py
  class TSNE (line 19) | class TSNE(BaseEstimator):
    method __init__ (line 22) | def __init__(
    method fit_transform (line 43) | def fit_transform(self, X, y=None):
    method _get_pairwise_affinities (line 85) | def _get_pairwise_affinities(self, X):
    method _binary_search (line 101) | def _binary_search(self, dist, target_entropy):
    method _q_distribution (line 131) | def _q_distribution(self, D):

FILE: mla/utils/main.py
  function one_hot (line 5) | def one_hot(y):
  function batch_iterator (line 10) | def batch_iterator(X, batch_size=64):