SYMBOL INDEX (114 symbols across 14 files)

FILE: fig/generate_gradient.py
  function main (line 27) | def main():
  function initial_norms (line 64) | def initial_norms(training_data, net):
  function training (line 69) | def training(training_data, net, epochs, filename):
  function plot_training (line 80) | def plot_training(epochs, filename, num_layers):
  function get_average_gradient (line 103) | def get_average_gradient(net, training_data):
  function zip_sum (line 109) | def zip_sum(a, b):
  function list_sum (line 112) | def list_sum(l):
  function list_norm (line 115) | def list_norm(l):

FILE: fig/mnist.py
  function main (line 21) | def main():
  function plot_images_together (line 27) | def plot_images_together(images):
  function plot_10_by_10_images (line 40) | def plot_10_by_10_images(images):
  function plot_images_separately (line 55) | def plot_images_separately(images):
  function plot_mnist_digit (line 65) | def plot_mnist_digit(image):
  function plot_2_and_1 (line 74) | def plot_2_and_1(images):
  function plot_top_left (line 87) | def plot_top_left(image):
  function plot_bad_images (line 98) | def plot_bad_images(images):
  function plot_really_bad_images (line 115) | def plot_really_bad_images(images):
  function plot_features (line 132) | def plot_features(image):
  function plot_rotated_image (line 156) | def plot_rotated_image(image):
  function load_data (line 218) | def load_data():
  function get_images (line 226) | def get_images(training_set):

FILE: fig/more_data.py
  function main (line 27) | def main():
  function run_networks (line 32) | def run_networks():
  function run_svms (line 51) | def run_svms():
  function make_plots (line 68) | def make_plots():
  function make_linear_plot (line 79) | def make_linear_plot(accuracies):
  function make_log_plot (line 91) | def make_log_plot(accuracies):
  function make_combined_plot (line 104) | def make_combined_plot(accuracies, svm_accuracies):

FILE: fig/multiple_eta.py
  function main (line 29) | def main():
  function run_networks (line 33) | def run_networks():
  function make_plot (line 55) | def make_plot():

FILE: fig/overfitting.py
  function main (line 23) | def main(filename, num_epochs,
  function run_network (line 44) | def run_network(filename, num_epochs, training_set_size=1000, lmbda=0.0):
  function make_plots (line 69) | def make_plots(filename, num_epochs,
  function plot_training_cost (line 90) | def plot_training_cost(training_cost, num_epochs, training_cost_xmin):
  function plot_test_accuracy (line 102) | def plot_test_accuracy(test_accuracy, num_epochs, test_accuracy_xmin):
  function plot_test_cost (line 115) | def plot_test_cost(test_cost, num_epochs, test_cost_xmin):
  function plot_training_accuracy (line 127) | def plot_training_accuracy(training_accuracy, num_epochs,
  function plot_overlay (line 141) | def plot_overlay(test_accuracy, training_accuracy, num_epochs, xmin,

FILE: fig/serialize_images_to_json.py
  function make_data_integer (line 27) | def make_data_integer(td):

FILE: fig/weight_initialization.py
  function main (line 26) | def main(filename, n, eta):
  function run_network (line 30) | def run_network(filename, n, eta):
  function make_plot (line 60) | def make_plot(filename):

FILE: src/conv.py
  function shallow (line 28) | def shallow(n=3, epochs=60):
  function basic_conv (line 41) | def basic_conv(n=3, epochs=60):
  function omit_FC (line 54) | def omit_FC():
  function dbl_conv (line 65) | def dbl_conv(activation_fn=sigmoid):
  function regularized_dbl_conv (line 88) | def regularized_dbl_conv():
  function dbl_conv_relu (line 103) | def dbl_conv_relu():
  function expanded_data (line 123) | def expanded_data(n=100):
  function expanded_data_double_fc (line 147) | def expanded_data_double_fc(n=100):
  function double_fc_dropout (line 171) | def double_fc_dropout(p0, p1, p2, repetitions):
  function ensemble (line 197) | def ensemble(nets):
  function plot_errors (line 233) | def plot_errors(error_locations, erroneous_predictions=None):
  function plot_filters (line 249) | def plot_filters(net, layer, x, y):
  function run_experiments (line 268) | def run_experiments():

FILE: src/mnist_average_darkness.py
  function main (line 27) | def main():
  function avg_darknesses (line 39) | def avg_darknesses(training_data):
  function guess_digit (line 54) | def guess_digit(image, avgs):

FILE: src/mnist_loader.py
  function load_data (line 19) | def load_data():
  function load_data_wrapper (line 47) | def load_data_wrapper():
  function vectorized_result (line 78) | def vectorized_result(j):

FILE: src/mnist_svm.py
  function svm_baseline (line 15) | def svm_baseline():

FILE: src/network.py
  class Network (line 19) | class Network(object):
    method __init__ (line 21) | def __init__(self, sizes):
    method feedforward (line 38) | def feedforward(self, a):
    method SGD (line 44) | def SGD(self, training_data, epochs, mini_batch_size, eta,
    method update_mini_batch (line 69) | def update_mini_batch(self, mini_batch, eta):
    method backprop (line 85) | def backprop(self, x, y):
    method evaluate (line 120) | def evaluate(self, test_data):
    method cost_derivative (line 129) | def cost_derivative(self, output_activations, y):
  function sigmoid (line 135) | def sigmoid(z):
  function sigmoid_prime (line 139) | def sigmoid_prime(z):

FILE: src/network2.py
  class QuadraticCost (line 26) | class QuadraticCost(object):
    method fn (line 29) | def fn(a, y):
    method delta (line 37) | def delta(z, a, y):
  class CrossEntropyCost (line 42) | class CrossEntropyCost(object):
    method fn (line 45) | def fn(a, y):
    method delta (line 57) | def delta(z, a, y):
  class Network (line 68) | class Network(object):
    method __init__ (line 70) | def __init__(self, sizes, cost=CrossEntropyCost):
    method default_weight_initializer (line 86) | def default_weight_initializer(self):
    method large_weight_initializer (line 103) | def large_weight_initializer(self):
    method feedforward (line 123) | def feedforward(self, a):
    method SGD (line 129) | def SGD(self, training_data, epochs, mini_batch_size, eta,
    method update_mini_batch (line 190) | def update_mini_batch(self, mini_batch, eta, lmbda, n):
    method backprop (line 209) | def backprop(self, x, y):
    method accuracy (line 243) | def accuracy(self, data, convert=False):
    method total_cost (line 274) | def total_cost(self, data, lmbda, convert=False):
    method save (line 290) | def save(self, filename):
  function load (line 301) | def load(filename):
  function vectorized_result (line 316) | def vectorized_result(j):
  function sigmoid (line 326) | def sigmoid(z):
  function sigmoid_prime (line 330) | def sigmoid_prime(z):

FILE: src/network3.py
  function linear (line 48) | def linear(z): return z
  function ReLU (line 49) | def ReLU(z): return T.maximum(0.0, z)
  function load_data_shared (line 67) | def load_data_shared(filename="../data/mnist.pkl.gz"):
  class Network (line 84) | class Network(object):
    method __init__ (line 86) | def __init__(self, layers, mini_batch_size):
    method SGD (line 106) | def SGD(self, training_data, epochs, mini_batch_size, eta,
  class ConvPoolLayer (line 188) | class ConvPoolLayer(object):
    method __init__ (line 196) | def __init__(self, filter_shape, image_shape, poolsize=(2, 2),
    method set_inpt (line 228) | def set_inpt(self, inpt, inpt_dropout, mini_batch_size):
  class FullyConnectedLayer (line 239) | class FullyConnectedLayer(object):
    method __init__ (line 241) | def __init__(self, n_in, n_out, activation_fn=sigmoid, p_dropout=0.0):
    method set_inpt (line 259) | def set_inpt(self, inpt, inpt_dropout, mini_batch_size):
    method accuracy (line 269) | def accuracy(self, y):
  class SoftmaxLayer (line 273) | class SoftmaxLayer(object):
    method __init__ (line 275) | def __init__(self, n_in, n_out, p_dropout=0.0):
    method set_inpt (line 288) | def set_inpt(self, inpt, inpt_dropout, mini_batch_size):
    method cost (line 296) | def cost(self, net):
    method accuracy (line 300) | def accuracy(self, y):
  function size (line 306) | def size(data):
  function dropout_layer (line 310) | def dropout_layer(layer, p_dropout):