SYMBOL INDEX (388 symbols across 76 files)

FILE: coursera-sequence-models/week-1-building-recurrent-network/dino.py
  function clip (line 16) | def clip(gradients, maxValue):
  function sample (line 40) | def sample(parameters, char_to_ix, seed):
  function optimize (line 117) | def optimize(X, Y, a_prev, parameters, learning_rate = 0.01):
  function model (line 161) | def model(data, ix_to_char, char_to_ix,

FILE: coursera-sequence-models/week-1-building-recurrent-network/rnn.py
  function rnn_cell_forward (line 5) | def rnn_cell_forward(xt, a_prev, parameters):
  function rnn_forward (line 45) | def rnn_forward(x, a0, parameters):
  function lstm_cell_forward (line 99) | def lstm_cell_forward(xt, a_prev, c_prev, parameters):
  function lstm_forward (line 167) | def lstm_forward(x, a0, parameters):

FILE: coursera-sequence-models/week-1-building-recurrent-network/rnn_provided.py
  function softmax (line 3) | def softmax(x):
  function smooth (line 7) | def smooth(loss, cur_loss):
  function print_sample (line 10) | def print_sample(sample_ix, ix_to_char):
  function get_initial_loss (line 15) | def get_initial_loss(vocab_size, seq_length):
  function softmax (line 18) | def softmax(x):
  function initialize_parameters (line 22) | def initialize_parameters(n_a, n_x, n_y):
  function rnn_step_forward (line 45) | def rnn_step_forward(parameters, a_prev, x):
  function rnn_step_backward (line 53) | def rnn_step_backward(dy, gradients, parameters, x, a, a_prev):
  function update_parameters (line 65) | def update_parameters(parameters, gradients, lr):
  function rnn_forward (line 74) | def rnn_forward(X, Y, a0, parameters, vocab_size = 27):
  function rnn_backward (line 102) | def rnn_backward(X, Y, parameters, cache):

FILE: coursera-sequence-models/week-1-building-recurrent-network/rnn_utils.py
  function softmax (line 3) | def softmax(x):
  function sigmoid (line 8) | def sigmoid(x):
  function initialize_adam (line 12) | def initialize_adam(parameters) :
  function update_parameters_with_adam (line 49) | def update_parameters_with_adam(parameters, grads, v, s, t, learning_rat...

FILE: coursera-sequence-models/week-1-building-recurrent-network/utils.py
  function softmax (line 3) | def softmax(x):
  function smooth (line 7) | def smooth(loss, cur_loss):
  function print_sample (line 10) | def print_sample(sample_ix, ix_to_char):
  function get_initial_loss (line 14) | def get_initial_loss(vocab_size, seq_length):
  function softmax (line 17) | def softmax(x):
  function initialize_parameters (line 21) | def initialize_parameters(n_a, n_x, n_y):
  function rnn_step_forward (line 44) | def rnn_step_forward(parameters, a_prev, x):
  function rnn_step_backward (line 52) | def rnn_step_backward(dy, gradients, parameters, x, a, a_prev):
  function update_parameters (line 64) | def update_parameters(parameters, gradients, lr):
  function rnn_forward (line 73) | def rnn_forward(X, Y, a0, parameters, vocab_size = 71):
  function rnn_backward (line 99) | def rnn_backward(X, Y, parameters, cache):

FILE: cs231n/_z.py
  function report_mean_image (line 49) | def report_mean_image(mimg):

FILE: cs231n/cifar10.py
  function _load_CIFAR_batch (line 18) | def _load_CIFAR_batch(filename):
  function load_CIFAR10 (line 29) | def load_CIFAR10(rootdir):
  function show_CIFAR10_samples (line 48) | def show_CIFAR10_samples(X_train, y_train):

FILE: cs231n/k_nearest_neighbor.py
  class KNearestNeighbor (line 6) | class KNearestNeighbor:
    method __init__ (line 8) | def __init__(self):
    method train (line 11) | def train(self, X, y):
    method compute_distances_two_loops (line 15) | def compute_distances_two_loops(self, X):
    method compute_distances_one_loop (line 35) | def compute_distances_one_loop(self, X):
    method compute_distances_no_loops (line 49) | def compute_distances_no_loops(self, X):
    method predict_labels (line 84) | def predict_labels(self, dists, k=1):

FILE: cs231n/k_nearest_neighbor_test.py
  class TestKNearestNeighborDistance (line 5) | class TestKNearestNeighborDistance(unittest.TestCase):
    method test_arange (line 7) | def test_arange(self):

FILE: cs231n/linear_classifier.py
  class LinearClassifier (line 10) | class LinearClassifier:
    method __init__ (line 11) | def __init__(self):
    method train (line 14) | def train(self,
    method predict (line 61) | def predict(self, X):

FILE: cs231n/linear_svm.py
  function svm_loss_naive (line 10) | def svm_loss_naive(W, X, y, reg):
  function svm_loss_vectorized (line 73) | def svm_loss_vectorized(W, X, y, reg):
  class LinearSVM (line 126) | class LinearSVM(linear_classifier.LinearClassifier):
    method loss (line 128) | def loss(self, X_batch, y_batch, reg):

FILE: cs231n/math_utils.py
  function rel_error (line 4) | def rel_error(x, y):
  function grad_check_sparse (line 9) | def grad_check_sparse(f, x, analytic_grad, num_checks):

FILE: cs231n/neural_net.py
  function two_layer_net (line 7) | def two_layer_net(X, model, y=None, reg=0.0):

FILE: cs231n/run_nn.py
  function init_toy_model (line 16) | def init_toy_model():
  function init_toy_data (line 36) | def init_toy_data():

FILE: cs231n/run_svm.py
  function report_mean_image (line 52) | def report_mean_image(mimg):

FILE: cs231n/softmax.py
  function softmax_loss_naive (line 8) | def softmax_loss_naive(W, X, y, reg):
  class Softmax (line 67) | class Softmax(linear_classifier.LinearClassifier):
    method loss (line 70) | def loss(self, X_batch, y_batch, reg):

FILE: cs231n/timer.py
  class Timer (line 5) | class Timer(object):
    method __init__ (line 6) | def __init__(self, name=None):
    method __enter__ (line 9) | def __enter__(self):
    method __exit__ (line 15) | def __exit__(self, type, value, traceback):

FILE: gradients/numgrad.py
  function eval_numerical_gradient (line 4) | def eval_numerical_gradient(f, x, verbose=False, h=1e-5):

FILE: gradients/sigmoid.py
  function sigmoid (line 7) | def sigmoid(z):
  function sigmoid_grad (line 26) | def sigmoid_grad(x):

FILE: gradients/tanh.py
  function tanh_grad (line 7) | def tanh_grad(x):

FILE: linear-regression/multiple_linear_regression.py
  function read_CCPP_data (line 15) | def read_CCPP_data(filename):
  function feature_normalize (line 28) | def feature_normalize(X):
  function compute_cost (line 42) | def compute_cost(X, y, theta):
  function gradient_descent (line 62) | def gradient_descent(X, y, nsteps, learning_rate=0.1):
  function compute_normal_eqn (line 92) | def compute_normal_eqn(X, y):
  function split_dataset_to_train_test (line 106) | def split_dataset_to_train_test(dataset, train_proportion=0.8):
  function compute_rsquared (line 129) | def compute_rsquared(X, y, theta):
  function plot_cost_vs_step (line 146) | def plot_cost_vs_step(costs):
  function plot_correlation_heatmap (line 158) | def plot_correlation_heatmap(X, header):
  function sample_predictions_vs_truth (line 174) | def sample_predictions_vs_truth(X, y, theta, nsamples=10):

FILE: linear-regression/multiple_linear_regression_test.py
  class Test (line 7) | class Test(unittest.TestCase):
    method test_feature_normalize (line 8) | def test_feature_normalize(self):

FILE: linear-regression/simple_linear_regression.py
  function generate_data (line 17) | def generate_data(n, m=2.25, b=6.0, stddev=1.5):
  function plot_data_scatterplot (line 30) | def plot_data_scatterplot(x, y, mb_history=None):
  function compute_cost (line 66) | def compute_cost(x, y, m, b):
  function gradient_descent (line 83) | def gradient_descent(x, y, nsteps, learning_rate=0.1):
  function plot_cost_3D (line 110) | def plot_cost_3D(x, y, costfunc, mb_history=None):
  function plot_cost_vs_step (line 149) | def plot_cost_vs_step(costs):
  function compute_mb_analytic (line 155) | def compute_mb_analytic(x, y):
  function compute_rsquared (line 164) | def compute_rsquared(x, y, m, b):

FILE: linear-regression/simple_linear_regression_test.py
  class Test (line 7) | class Test(unittest.TestCase):
    method test_compute_cost (line 8) | def test_compute_cost(self):

FILE: linear-regression/timer.py
  class Timer (line 5) | class Timer(object):
    method __init__ (line 6) | def __init__(self, name=None):
    method __enter__ (line 9) | def __enter__(self):
    method __exit__ (line 15) | def __exit__(self, type, value, traceback):

FILE: llama2-from-scratch/inference.py
  class LLaMA (line 12) | class LLaMA:
    method __init__ (line 13) | def __init__(
    method build (line 24) | def build(
    method text_completion (line 70) | def text_completion(
    method _sample_top_p (line 148) | def _sample_top_p(self, probs, p):

FILE: llama2-from-scratch/model.py
  function precompute_theta_pos_frequencies (line 9) | def precompute_theta_pos_frequencies(
  function apply_rotary_embeddings (line 33) | def apply_rotary_embeddings(x: torch.Tensor, freqs_complex: torch.Tensor...
  class ModelArgs (line 54) | class ModelArgs:
  function repeat_kv (line 74) | def repeat_kv(x: torch.Tensor, n_rep: int):
  class RMSNorm (line 87) | class RMSNorm(nn.Module):
    method __init__ (line 88) | def __init__(self, dim: int, eps: float = 1e-6):
    method _norm (line 94) | def _norm(self, x: torch.Tensor):
    method forward (line 99) | def forward(self, x: torch.Tensor):
  class SelfAttention (line 104) | class SelfAttention(nn.Module):
    method __init__ (line 105) | def __init__(self, args: ModelArgs):
    method forward (line 135) | def forward(self, x: torch.Tensor, start_pos: int, freqs_complex: torc...
  class FeedForward (line 188) | class FeedForward(nn.Module):
    method __init__ (line 189) | def __init__(self, args: ModelArgs):
    method forward (line 208) | def forward(self, x: torch.Tensor):
  class EncoderBlock (line 216) | class EncoderBlock(nn.Module):
    method __init__ (line 217) | def __init__(self, args: ModelArgs) -> None:
    method forward (line 233) | def forward(self, x: torch.Tensor, start_pos: int, freqs_complex: torc...
  class Transformer (line 240) | class Transformer(nn.Module):
    method __init__ (line 241) | def __init__(self, args: ModelArgs) -> None:
    method forward (line 268) | def forward(self, tokens: torch.Tensor, start_pos: int):

FILE: logistic-regression/mnist_dataset.py
  function maybe_download (line 17) | def maybe_download(base_url, filename, expected_size, force=False):
  function load_pickle_from_gz (line 35) | def load_pickle_from_gz(filename):
  function get_mnist_data (line 41) | def get_mnist_data():
  function display_mnist_image (line 59) | def display_mnist_image(x, y=None):
  function display_multiple_images (line 72) | def display_multiple_images(xs):
  function convert_y_to_binary (line 83) | def convert_y_to_binary(y, correct_digit):

FILE: logistic-regression/mnist_multinomial_classifier.py
  function train_for_digit (line 17) | def train_for_digit(X, y, digit, nsteps, learning_rate=0.12, reg_beta=0....

FILE: logistic-regression/mnist_softmax_classifier.py
  function train (line 14) | def train(X, y, nsteps, learning_rate=0.09, reg_beta=0.01):

FILE: logistic-regression/regression_lib.py
  function augment_1s_column (line 8) | def augment_1s_column(X):
  function feature_normalize (line 18) | def feature_normalize(X):
  function predict_binary (line 38) | def predict_binary(X, theta):
  function sigmoid (line 58) | def sigmoid(z):
  function softmax_layer (line 78) | def softmax_layer(X, W):
  function softmax_cross_entropy_loss (line 99) | def softmax_cross_entropy_loss(X, y, W, reg_beta=0.0):
  function predict_logistic_probability (line 136) | def predict_logistic_probability(X, theta):
  function cross_entropy_loss_binary (line 150) | def cross_entropy_loss_binary(X, y, theta, reg_beta=0.0):
  function square_loss (line 178) | def square_loss(X, y, theta, reg_beta=0.0):
  function hinge_loss (line 207) | def hinge_loss(X, y, theta, reg_beta=0.0):
  function generate_batch (line 238) | def generate_batch(X, y, batch_size=256):
  function gradient_descent (line 250) | def gradient_descent(X, y, init_theta,

FILE: logistic-regression/regression_lib_test.py
  function hinge_loss_simple (line 13) | def hinge_loss_simple(X, y, theta, reg_beta=0.0):
  function cross_entropy_loss_binary_simple (line 41) | def cross_entropy_loss_binary_simple(X, y, theta, reg_beta=0.0):
  function softmax_gradient_simple (line 61) | def softmax_gradient_simple(z):
  function eval_numerical_gradient (line 78) | def eval_numerical_gradient(f, x, verbose=False, h=1e-5):
  class TestSquareLoss (line 109) | class TestSquareLoss(unittest.TestCase):
    method test_simple_vs_numerical_noreg (line 110) | def test_simple_vs_numerical_noreg(self):
    method test_simple_vs_numerical_withreg (line 131) | def test_simple_vs_numerical_withreg(self):
  class TestHingeLoss (line 156) | class TestHingeLoss(unittest.TestCase):
    method checkHingeLossSimpleVsVec (line 157) | def checkHingeLossSimpleVsVec(self, X, y, theta, reg_beta=0.0):
    method test_hinge_loss_small (line 163) | def test_hinge_loss_small(self):
    method test_hinge_loss_larger_random (line 192) | def test_hinge_loss_larger_random(self):
    method test_hinge_loss_even_larger_random (line 200) | def test_hinge_loss_even_larger_random(self):
  class TestCrossEntropyBinaryLoss (line 209) | class TestCrossEntropyBinaryLoss(unittest.TestCase):
    method checkXentLossSimpleVsVec (line 210) | def checkXentLossSimpleVsVec(self, X, y, theta, reg_beta=0.0):
    method test_xent_no_overflow_from_0 (line 217) | def test_xent_no_overflow_from_0(self):
    method test_xent_loss_oneitem (line 227) | def test_xent_loss_oneitem(self):
    method test_xent_loss_small (line 245) | def test_xent_loss_small(self):
    method test_xent_loss_larger (line 272) | def test_xent_loss_larger(self):
  class TestPredictBinary (line 303) | class TestPredictBinary(unittest.TestCase):
    method test_simple (line 304) | def test_simple(self):
  class TestPredictLogisticProbability (line 315) | class TestPredictLogisticProbability(unittest.TestCase):
    method test_close_to_zero (line 316) | def test_close_to_zero(self):
    method test_close_to_one (line 326) | def test_close_to_one(self):
    method test_half (line 336) | def test_half(self):
  function tuplize_2d_array (line 347) | def tuplize_2d_array(arr):
  class TestGenerateBatch (line 352) | class TestGenerateBatch(unittest.TestCase):
    method test_simple (line 353) | def test_simple(self):
    method test_with_row_y (line 380) | def test_with_row_y(self):
  class TestGradientDescent (line 397) | class TestGradientDescent(unittest.TestCase):
    method test_applies_dtheta (line 398) | def test_applies_dtheta(self):
  class TestFeatureNormalize (line 426) | class TestFeatureNormalize(unittest.TestCase):
    method test_simple (line 427) | def test_simple(self):
    method test_with_nans (line 437) | def test_with_nans(self):
  class TestSoftmaxCrossEntropyLoss (line 449) | class TestSoftmaxCrossEntropyLoss(unittest.TestCase):
    method checkGradientVsNumeric (line 450) | def checkGradientVsNumeric(self, X, y, W, reg_beta):
    method test_trivial (line 458) | def test_trivial(self):
    method test_random_small (line 473) | def test_random_small(self):

FILE: logistic-regression/simple_binary_classifier.py
  function generate_data (line 15) | def generate_data(k, num_neg_outliers=0):
  function plot_data_scatterplot (line 48) | def plot_data_scatterplot(X, y, thetas=[]):
  function L01_loss (line 87) | def L01_loss(X, y, theta):
  function search_best_L01_loss (line 101) | def search_best_L01_loss(X, y, theta_start=None,
  function run_gradient_descent_search (line 148) | def run_gradient_descent_search(X, y, lossfunc, max_nsteps, learning_rate,

FILE: logistic-regression/timer.py
  class Timer (line 5) | class Timer(object):
    method __init__ (line 6) | def __init__(self, name=None):
    method __enter__ (line 9) | def __enter__(self):
    method __exit__ (line 15) | def __exit__(self, type, value, traceback):

FILE: min-char-rnn/markov-model.py
  function weighted_from_counter (line 20) | def weighted_from_counter(c):
  function main (line 29) | def main():

FILE: min-char-rnn/min-char-lstm.py
  function sigmoid (line 74) | def sigmoid(z):
  function lossFun (line 94) | def lossFun(inputs, targets, hprev, cprev):
  function sample (line 231) | def sample(h, c, seed_ix, n):
  function gradCheck (line 262) | def gradCheck(inputs, targets, hprev, cprev):
  function basicGradCheck (line 291) | def basicGradCheck():

FILE: min-char-rnn/min-char-rnn.py
  function lossFun (line 73) | def lossFun(inputs, targets, hprev):
  function sample (line 161) | def sample(h, seed_ix, n):
  function gradCheck (line 190) | def gradCheck(inputs, targets, hprev):
  function basicGradCheck (line 218) | def basicGradCheck():

FILE: min-char-rnn/preprocess-cnus.py
  function clean_line (line 6) | def clean_line(line):

FILE: nanogpt-lecture/bigram.py
  function get_batch (line 45) | def get_batch(split):
  class BigramLanguageMode (line 55) | class BigramLanguageMode(nn.Module):
    method __init__ (line 56) | def __init__(self, vocab_size):
    method forward (line 67) | def forward(self, idx, targets=None):
    method generate (line 86) | def generate(self, idx, max_new_tokens):
  function estimate_loss (line 125) | def estimate_loss():

FILE: nanogpt-lecture/explore-input.py
  function get_batch (line 74) | def get_batch(split):

FILE: nanogpt-lecture/gpt.py
  function get_batch (line 67) | def get_batch(split):
  class Head (line 76) | class Head(nn.Module):
    method __init__ (line 79) | def __init__(self, head_size):
    method forward (line 87) | def forward(self, x):
  class MultiHeadAttention (line 106) | class MultiHeadAttention(nn.Module):
    method __init__ (line 109) | def __init__(self, num_heads, head_size):
    method forward (line 115) | def forward(self, x):
  class FeedFoward (line 124) | class FeedFoward(nn.Module):
    method __init__ (line 127) | def __init__(self, n_embd):
    method forward (line 136) | def forward(self, x):
  class Block (line 140) | class Block(nn.Module):
    method __init__ (line 143) | def __init__(self, n_embd, n_head):
    method forward (line 152) | def forward(self, x):
  class GPTLanguageModel (line 158) | class GPTLanguageModel(nn.Module):
    method __init__ (line 160) | def __init__(self):
    method _init_weights (line 176) | def _init_weights(self, module):
    method forward (line 184) | def forward(self, idx, targets=None):
    method generate (line 211) | def generate(self, idx, max_new_tokens):
  function estimate_loss (line 239) | def estimate_loss():

FILE: numpy-shapes-tutorial/hello.py
  function main (line 1) | def main():

FILE: pytorch-samples/attention-head.py
  class Head (line 22) | class Head(nn.Module):
    method __init__ (line 25) | def __init__(self, C, head_size, do_mask=False):
    method forward (line 34) | def forward(self, x):
  class MultiHeadAttention (line 55) | class MultiHeadAttention(nn.Module):
    method __init__ (line 58) | def __init__(self, C, num_heads, head_size, do_mask=False):
    method forward (line 66) | def forward(self, x):

FILE: pytorch-samples/basic-device.py
  class MyModel (line 8) | class MyModel(nn.Module):
    method __init__ (line 9) | def __init__(self):
    method forward (line 13) | def forward(self, x):

FILE: pytorch-samples/moe.py
  class ModelParams (line 10) | class ModelParams:
  class FF (line 26) | class FF(nn.Module):
    method __init__ (line 27) | def __init__(self):
    method forward (line 32) | def forward(self, x):
  class Moe (line 36) | class Moe(nn.Module):
    method __init__ (line 37) | def __init__(self, experts: List[nn.Module], gate: nn.Module):
    method forward (line 42) | def forward(self, x):

FILE: pytorch-samples/topk.py
  function topk_np (line 17) | def topk_np(x, k):

FILE: softmax/softmax.py
  function softmax (line 9) | def softmax(z):
  function softmax_gradient (line 21) | def softmax_gradient(z):
  function softmax_gradient_simple (line 38) | def softmax_gradient_simple(z):
  function fully_connected_gradient (line 55) | def fully_connected_gradient(x, W):
  function softmax_layer (line 84) | def softmax_layer(x, W):
  function softmax_layer_gradient (line 99) | def softmax_layer_gradient(x, W):
  function softmax_layer_gradient_direct (line 116) | def softmax_layer_gradient_direct(x, W):
  function cross_entropy_loss (line 136) | def cross_entropy_loss(p, y):
  function cross_entropy_loss_gradient (line 148) | def cross_entropy_loss_gradient(p, y):
  function softmax_cross_entropy_loss_gradient (line 169) | def softmax_cross_entropy_loss_gradient(x, W, y):
  function softmax_cross_entropy_loss_gradient_direct (line 182) | def softmax_cross_entropy_loss_gradient_direct(x, W, y):

FILE: softmax/softmax_test.py
  function eval_numerical_gradient (line 12) | def eval_numerical_gradient(f, x, verbose=False, h=1e-5):
  class TestSoftmaxGradient (line 47) | class TestSoftmaxGradient(unittest.TestCase):
    method checkSoftmaxGradientSimpleVsVec (line 48) | def checkSoftmaxGradientSimpleVsVec(self, z):
    method test_simple_vs_numerical (line 53) | def test_simple_vs_numerical(self):
    method test_simple_vs_vectorized_small (line 69) | def test_simple_vs_vectorized_small(self):
    method test_simple_vs_vectorized_larger (line 75) | def test_simple_vs_vectorized_larger(self):
    method test_simple_vs_vectorized_random (line 84) | def test_simple_vs_vectorized_random(self):
  class TestFullyConnectedGradient (line 89) | class TestFullyConnectedGradient(unittest.TestCase):
    method test_small (line 90) | def test_small(self):
  class TestSoftmaxLayerGradient (line 106) | class TestSoftmaxLayerGradient(unittest.TestCase):
    method checkForData (line 107) | def checkForData(self, x, W, rtol=1e-5, atol=1e-8):
    method test_small (line 121) | def test_small(self):
    method test_bigger (line 131) | def test_bigger(self):
    method test_random_big (line 144) | def test_random_big(self):
  class TestCrossEntropyLossAndGradient (line 153) | class TestCrossEntropyLossAndGradient(unittest.TestCase):
    method test_cross_entropy_with_onehot_y (line 154) | def test_cross_entropy_with_onehot_y(self):
  class TestSoftmaxCrossEntropyLossGradient (line 172) | class TestSoftmaxCrossEntropyLossGradient(unittest.TestCase):
    method checkForData (line 173) | def checkForData(self, x, W, y, rtol=1e-5, atol=1e-8):
    method test_small (line 186) | def test_small(self):
    method test_random_big (line 203) | def test_random_big(self):

FILE: tensorflow-samples/conv2d-numpy.py
  function conv2d_single_channel (line 11) | def conv2d_single_channel(input, w):
  function conv2d_multi_channel (line 44) | def conv2d_multi_channel(input, w):
  function tf_conv2d_single_channel (line 85) | def tf_conv2d_single_channel(input, w):
  function tf_conv2d_multi_channel (line 104) | def tf_conv2d_multi_channel(input, w):
  function depthwise_conv2d (line 122) | def depthwise_conv2d(input, w):
  function separable_conv2d (line 158) | def separable_conv2d(input, w_depth, w_pointwise):
  function tf_depthwise_conv2d (line 191) | def tf_depthwise_conv2d(input, w):
  function tf_separable_conv2d (line 209) | def tf_separable_conv2d(input, w_depth, w_pointwise):
  class TestConvs (line 235) | class TestConvs(unittest.TestCase):
    method test_single_channel (line 236) | def test_single_channel(self):
    method test_multi_channel (line 249) | def test_multi_channel(self):
    method test_depthwise (line 268) | def test_depthwise(self):
    method test_separable (line 288) | def test_separable(self):

FILE: transformer-attention/experimental/position_enc_sin.py
  function position_enc_sin_single (line 8) | def position_enc_sin_single(x):
  function position_enc_sin (line 27) | def position_enc_sin(x):

FILE: transformer-attention/moe.py
  function feed_forward_relu (line 8) | def feed_forward_relu(x, W1, W2):
  function topk_lastdim (line 28) | def topk_lastdim(x, k):
  class FFParams (line 42) | class FFParams:
  class MoEParams (line 49) | class MoEParams:
  function moe (line 69) | def moe(x: np.ndarray, params: MoEParams):

FILE: transformer-attention/multiheadattention.py
  function multihead_attention_vec (line 16) | def multihead_attention_vec(x, W, NH, Wp, do_mask=False):
  function multihead_attention_list (line 63) | def multihead_attention_list(x, Wqs, Wks, Wvs, Wp, do_mask=False):
  function multihead_cross_attention_list (line 111) | def multihead_cross_attention_list(xq, xv, Wqs, Wks, Wvs, Wp):

FILE: transformer-attention/selfattention.py
  function self_attention (line 13) | def self_attention(x, Wk, Wq, Wv):
  function self_attention_batched (line 32) | def self_attention_batched(x, Wk, Wq, Wv):
  function self_attention_cols (line 49) | def self_attention_cols(x, Wk, Wq, Wv, Bk, Bq, Bv):

FILE: transformer-attention/softmax.py
  function softmax_lastdim (line 4) | def softmax_lastdim(x):
  function softmax_cols (line 16) | def softmax_cols(x):

FILE: transformer-attention/test_moe.py
  function test_topk_lastdim (line 5) | def test_topk_lastdim():

FILE: transformer-attention/test_multiheadattention.py
  function test_values_vec (line 9) | def test_values_vec():
  function test_shapes (line 38) | def test_shapes():
  function test_values (line 55) | def test_values():
  function test_shapes_cross (line 79) | def test_shapes_cross():

FILE: transformer-attention/test_selfattention.py
  function test_shapes_cols (line 5) | def test_shapes_cols():
  function test_shapes_rows (line 19) | def test_shapes_rows():
  function test_rows_values (line 30) | def test_rows_values():
  function test_batched (line 57) | def test_batched():

FILE: ud730/assign1_train_logistic.py
  function get_data_and_labels (line 16) | def get_data_and_labels(dataset, labelset, nmax=None, shuffle=False):

FILE: ud730/assign2_tf_sgd.py
  function reformat (line 28) | def reformat(dataset, labels):
  function accuracy (line 41) | def accuracy(predictions, labels):
  function run_gradient_descent (line 45) | def run_gradient_descent():
  function run_sgd (line 117) | def run_sgd():
  function run_sgd_with_hidden_layer (line 178) | def run_sgd_with_hidden_layer(num_steps=3001):

FILE: ud730/assign3_regularization.py
  function reformat (line 24) | def reformat(dataset, labels):
  function accuracy (line 36) | def accuracy(predictions, labels):
  function run_sgd_with_reg (line 40) | def run_sgd_with_reg():
  function run_sgd_with_hidden_layer_with_reg (line 112) | def run_sgd_with_hidden_layer_with_reg(num_steps=3001,

FILE: ud730/assign4_conv.py
  function reformat (line 25) | def reformat(dataset, labels):
  function accuracy (line 37) | def accuracy(predictions, labels):
  function conv_with_stride (line 46) | def conv_with_stride(num_steps=1001):
  function conv_with_pooling (line 125) | def conv_with_pooling(num_steps=1001, learning_rate=0.1):

FILE: ud730/assign5_cbow.py
  function generate_batch_cbow (line 14) | def generate_batch_cbow(data, batch_size, context_size):

FILE: ud730/assign5_word2vec.py
  function generate_batch_skipgram (line 41) | def generate_batch_skipgram(batch_size, num_skips, skip_window):
  function do_report_distances (line 118) | def do_report_distances(emb):
  function plot (line 214) | def plot(embeddings, labels):

FILE: ud730/assign6.py
  function char2id (line 30) | def char2id(char):
  function id2char (line 40) | def id2char(dictid):
  class BatchGenerator (line 54) | class BatchGenerator(object):
    method __init__ (line 55) | def __init__(self, text, batch_size, num_unrollings):
    method _next_batch (line 64) | def _next_batch(self):
    method next (line 84) | def next(self):
  function characters (line 97) | def characters(probabilities):
  function batches2string (line 105) | def batches2string(batches):
  function logprob (line 131) | def logprob(predictions, labels):
  function sample_distribution (line 136) | def sample_distribution(distribution):
  function sample (line 148) | def sample(prediction):
  function random_distribution (line 154) | def random_distribution():
  function lstm_cell (line 189) | def lstm_cell(i, o, state):

FILE: ud730/notmnist_prepare_data.py
  function download_progress_hook (line 20) | def download_progress_hook(count, blockSize, totalSize):
  function maybe_download (line 36) | def maybe_download(filename, expected_bytes, force=False):
  function maybe_extract (line 53) | def maybe_extract(filename, force=False):
  function load_letter (line 80) | def load_letter(folder, min_num_images):
  function maybe_pickle (line 109) | def maybe_pickle(data_folders, min_num_images_per_class, force=False):
  function check_dataset_balance (line 131) | def check_dataset_balance(datasets):
  function make_arrays (line 144) | def make_arrays(nb_rows, img_size):
  function merge_datasets (line 152) | def merge_datasets(pickle_files, train_size, valid_size=0):
  function randomize (line 199) | def randomize(dataset, labels):

FILE: ud730/softmax.py
  function softmax (line 7) | def softmax(x):

FILE: ud730/timer.py
  class Timer (line 5) | class Timer(object):
    method __init__ (line 6) | def __init__(self, name=None):
    method __enter__ (line 9) | def __enter__(self):
    method __exit__ (line 15) | def __exit__(self, type, value, traceback):

FILE: ud730/utils.py
  function show_image (line 9) | def show_image(imgarr):
  function shuffle_data_and_labels (line 25) | def shuffle_data_and_labels(dataset, labels):
  class Timer (line 33) | class Timer(object):
    method __init__ (line 34) | def __init__(self, name=None):
    method __enter__ (line 37) | def __enter__(self):
    method __exit__ (line 40) | def __exit__(self, type, value, traceback):

FILE: ud730/word_utils.py
  function maybe_download (line 12) | def maybe_download(filename, expected_bytes):
  function read_data (line 30) | def read_data(filename):
  function read_data_asstring (line 37) | def read_data_asstring(filename):
  function build_dataset (line 46) | def build_dataset(words, vocabulary_size=50000):
  function report_words_distance (line 79) | def report_words_distance(w1, w2, dictionary, embeddings):

FILE: understanding-deep-learning-book/nb-04-03-deep-networks.py
  function ReLU (line 8) | def ReLU(preactivation):
  function shallow_1_1_3 (line 14) | def shallow_1_1_3(
  function plot_neural (line 46) | def plot_neural(x, y):

FILE: understanding-deep-learning-book/nb-10-01-1d-convolution.py
  function conv_3_1_1_zp (line 21) | def conv_3_1_1_zp(x_in, omega):

FILE: understanding-deep-learning-book/nb-12-01-self-attention.py
  function softmax (line 50) | def softmax(x):
  function softmax_cols (line 91) | def softmax_cols(data_in):
  function self_attention (line 107) | def self_attention(

FILE: understanding-deep-learning-book/nb-12-02-multihead-attention.py
  function softmax_cols (line 43) | def softmax_cols(data_in):
  function multihead_scaled_self_attention (line 54) | def multihead_scaled_self_attention(

FILE: word2vec-jax/make-train-data.py
  function read_words_from_file (line 15) | def read_words_from_file(file_path):
  function subsample (line 24) | def subsample(words, threshold=1e-4):
  function make_vocabulary (line 44) | def make_vocabulary(words, top_k=20000):

FILE: word2vec-jax/similar-words.py
  function find_similar_words (line 7) | def find_similar_words(word, vocab, inv_vocab, embedding, top_k=10):
  function find_analogies (line 37) | def find_analogies(a, b, c, vocab, inv_vocab, embedding, top_k=10):
  function show_similarity (line 68) | def show_similarity(w, cs, vocab, inv_vocab, embedding):

FILE: word2vec-jax/train.py
  function generate_train_vectors (line 8) | def generate_train_vectors(train_data, vocab, window_size=4, batch_size=...
  function word2vec_forward (line 43) | def word2vec_forward(params, context):
  function word2vec_loss (line 66) | def word2vec_loss(params, target, context):
  function train (line 75) | def train(train_data, vocab):