v_1 * w_1 + ... + v_n * w_n

returns a random draw from a standard normal distribution

returns a num_rows x num_cols matrix whose (i,j)-th entry is entry_fn(i, j)

returns the pth-percentile value in x

classify the input using the given decision tree

translate x by subtracting its mean (so the result has mean 0)

returns a function that picks a field out of a dict

Create a terminal node value

returns the value in this cluster (if it's a leaf cluster) or all the values in the leaf clusters below it (if it's not)

find approximate inverse using binary search

choose k random points as the initial means

evaluates stats_fn on num_samples bootstrap samples from data

takes in a neural network (represented as a list of lists of lists of weights) and returns the output from forward-propagating the input

This method selects the best split for the dataset

a cluster is a leaf if it has length 1

v_1 * v_1 + ... + v_n * v_n

subtracts two vectors componentwise

This method predicts the accuracy percentage

the contribution of row x_i to the gradient of the direction-w variance

the variance of the row x_i in the direction w

returns the two children of this cluster if it's a merged cluster; raises an Exception if this is a leaf cluster

each labeled point should be a pair (point, label)

use gradient descent to find theta that minimizes target function

return a function that for any input x returns -f(x)

the same when f returns a list of numbers

finds mu and sigma corresponding to a Binomial(n, p)

returns the symmetric (about the mean) bounds that contain the specified probability

returns the z for which P(Z <= z) = probability

returns a dict of inputs partitioned by the attribute each input is a pair (attribute_dict, label)

computes the entropy corresponding to the given partition

return a matplotlib 'patch' object with the specified location, crosshatch pattern, and color

rescales the input data so that each column has mean 0 and standard deviation 1 ignores columns with no deviation

move step_size in the direction from v

computes the sum of squared elements in v

Tokenise message into distinct words

wraps f to return None if f raises an exception assumes f takes only one input

assumes x has at least two elements

a normalizing constant so that the total probability is 1

This method makes a prediction a list of bagged trees

randomly samples len(data) elements with replacement

floor the point to the next lower multiple of bucket_size

This method builds a decision tree