SYMBOL INDEX (201 symbols across 15 files)

FILE: anfis.py
  class FuzzifyVariable (line 23) | class FuzzifyVariable(torch.nn.Module):
    method __init__ (line 28) | def __init__(self, mfdefs):
    method num_mfs (line 37) | def num_mfs(self):
    method members (line 41) | def members(self):
    method pad_to (line 48) | def pad_to(self, new_size):
    method fuzzify (line 55) | def fuzzify(self, x):
    method forward (line 63) | def forward(self, x):
  class FuzzifyLayer (line 76) | class FuzzifyLayer(torch.nn.Module):
    method __init__ (line 83) | def __init__(self, varmfs, varnames=None):
    method num_in (line 95) | def num_in(self):
    method max_mfs (line 100) | def max_mfs(self):
    method __repr__ (line 104) | def __repr__(self):
    method forward (line 118) | def forward(self, x):
  class AntecedentLayer (line 131) | class AntecedentLayer(torch.nn.Module):
    method __init__ (line 136) | def __init__(self, varlist):
    method num_rules (line 145) | def num_rules(self):
    method extra_repr (line 148) | def extra_repr(self, varlist=None):
    method forward (line 161) | def forward(self, x):
  class ConsequentLayer (line 176) | class ConsequentLayer(torch.nn.Module):
    method __init__ (line 182) | def __init__(self, d_in, d_rule, d_out):
    method coeff (line 188) | def coeff(self):
    method coeff (line 196) | def coeff(self, new_coeff):
    method fit_coeff (line 207) | def fit_coeff(self, x, weights, y_actual):
    method forward (line 237) | def forward(self, x):
  class PlainConsequentLayer (line 251) | class PlainConsequentLayer(ConsequentLayer):
    method __init__ (line 256) | def __init__(self, *params):
    method coeff (line 262) | def coeff(self):
    method fit_coeff (line 269) | def fit_coeff(self, x, weights, y_actual):
  class WeightedSumLayer (line 276) | class WeightedSumLayer(torch.nn.Module):
    method __init__ (line 282) | def __init__(self):
    method forward (line 285) | def forward(self, weights, tsk):
  class AnfisNet (line 296) | class AnfisNet(torch.nn.Module):
    method __init__ (line 302) | def __init__(self, description, invardefs, outvarnames, hybrid=True):
    method num_out (line 324) | def num_out(self):
    method coeff (line 328) | def coeff(self):
    method coeff (line 332) | def coeff(self, new_coeff):
    method fit_coeff (line 335) | def fit_coeff(self, x, y_actual):
    method input_variables (line 344) | def input_variables(self):
    method output_variables (line 351) | def output_variables(self):
    method extra_repr (line 357) | def extra_repr(self):
    method forward (line 366) | def forward(self, x):
  function module_hook (line 384) | def module_hook(label):
  function tensor_hook (line 396) | def tensor_hook(label):

FILE: cmeans.py
  class FuzzyCluster (line 27) | class FuzzyCluster(torch.nn.Module):
    method __init__ (line 38) | def __init__(self, n_c, n_in, m=1.7):
    method set_centroids (line 51) | def set_centroids(self, new_centroids):
    method register_centroids (line 54) | def register_centroids(self):
    method _cdist (line 65) | def _cdist(x1, x2):
    method recalc_centroids (line 80) | def recalc_centroids(self, x, u):
    method forward (line 95) | def forward(self, x):
  function plot_clusters (line 107) | def plot_clusters(x, fc):
  function evaluate_clustering (line 123) | def evaluate_clustering(datset, fc):
  function cmeans_cluster (line 134) | def cmeans_cluster(dataset, num_clusters, max_epochs=250, show_plots=True):
  function sgd_cluster (line 162) | def sgd_cluster(dataset, num_clusters, epochs=250, show_plots=True):
  function read_data (line 199) | def read_data(filename, n_in=2):
  function read_and_cluster (line 221) | def read_and_cluster(filename, n_c, n_in=2):

FILE: experimental.py
  class TwoLayerNet (line 16) | class TwoLayerNet(torch.nn.Module):
    method __init__ (line 21) | def __init__(self, d_in, hidden_size, d_out):
    method forward (line 26) | def forward(self, x):
  function linear_model (line 32) | def linear_model(x, y, epochs=200, hidden_size=10):
  function plotErrors (line 57) | def plotErrors(errors):
  function plotResults (line 67) | def plotResults(y_actual, y_predicted):
  function _plot_mfs (line 78) | def _plot_mfs(var_name, fv, x):
  function plot_all_mfs (line 93) | def plot_all_mfs(model, x):
  function calc_error (line 98) | def calc_error(y_pred, y_actual):
  function test_anfis (line 107) | def test_anfis(model, data, show_plots=False):
  function train_anfis_with (line 123) | def train_anfis_with(model, data, optimizer, criterion,
  function train_anfis (line 162) | def train_anfis(model, data, epochs=500, show_plots=False):

FILE: fileio/EvaluateXML.java
  class EvaluateXML (line 6) | public class EvaluateXML
    method evaluate (line 12) | private static float evaluate(float angle, float change)
    method main (line 27) | public static void main(String[] args)

FILE: fileio/astext.py
  function _read_comment_line (line 28) | def _read_comment_line(fh, fstr):
  function _read_mf_line (line 40) | def _read_mf_line(fh):
  function _read_rule_line (line 55) | def _read_rule_line(fh):
  function read (line 65) | def read(filename):
  function show (line 92) | def show(model, fh=sys.stdout):
  function write (line 117) | def write(model, filename):

FILE: fileio/fcl.py
  function _in_mf_def (line 24) | def _in_mf_def(mfdef):
  function _out_mf_def (line 44) | def _out_mf_def(rule):
  function _out_mf_name (line 52) | def _out_mf_name(outnum, rnum):
  function _show_antecedents (line 59) | def _show_antecedents(rules, invars):
  function show (line 74) | def show(model, fh=sys.stdout):
  function write (line 124) | def write(model, filename):

FILE: fileio/test_tojfml.py
  function jfml_pendulum_2_domains (line 22) | def jfml_pendulum_2_domains():
  function jfml_pendulum_2_model (line 26) | def jfml_pendulum_2_model():

FILE: fileio/tojfml.py
  function _in_mf_def (line 28) | def _in_mf_def(mfname, mfdef):
  function _out_mf_name (line 51) | def _out_mf_name(outnum, rnum):
  function _out_mf_def (line 58) | def _out_mf_def(mfname, rule):
  function _mk_antecedents (line 69) | def _mk_antecedents(local_jfml, rules, invars):
  function _mk_consequents (line 87) | def _mk_consequents(local_jfml, conseq, onames):
  class _LocalJFML (line 104) | class _LocalJFML:
    method __init__ (line 110) | def __init__(self):
    method set_in_variable (line 114) | def set_in_variable(self, varname, domain):
    method set_out_variable (line 122) | def set_out_variable(self, varname):
    method get_variable (line 130) | def get_variable(self, varname):
    method set_in_term (line 133) | def set_in_term(self, varname, mfname, mfdef):
    method set_out_term (line 138) | def set_out_term(self, varname, mfname, coeffs):
    method get_term (line 143) | def get_term(self, varname, mfname):
  function convert (line 147) | def convert(model, domains):
  function write_xml (line 188) | def write_xml(model, domains, filename):

FILE: iris_example.py
  function make_one_hot (line 21) | def make_one_hot(data, num_categories, dtype=torch.float):
  function get_iris_data_one_hot (line 37) | def get_iris_data_one_hot(in_feat=2, batch_size=1024):
  function get_iris_data (line 50) | def get_iris_data(in_feat=2, batch_size=1024):
  function vignette_ex5 (line 63) | def vignette_ex5(in_feat=2):
  function num_cat_correct (line 80) | def num_cat_correct(model, x, y_actual):
  function train_hybrid (line 94) | def train_hybrid(in_feat=2):
  function train_non_hybrid (line 112) | def train_non_hybrid(in_feat=2):

FILE: jang_examples.py
  function sinc (line 25) | def sinc(x, y):
  function make_sinc_xy (line 35) | def make_sinc_xy(batch_size=1024):
  function make_sinc_xy_large (line 47) | def make_sinc_xy_large(num_cases=10000, batch_size=1024):
  function make_sinc_xy2 (line 59) | def make_sinc_xy2(batch_size=1024):
  function ex1_model (line 71) | def ex1_model():
  function ex2_eqn (line 86) | def ex2_eqn(x, y, z):
  function _make_data_xyz (line 95) | def _make_data_xyz(inp_range):
  function ex2_model (line 106) | def ex2_model():
  function ex2_training_data (line 117) | def ex2_training_data(batch_size=1024):
  function ex2_testing_data (line 126) | def ex2_testing_data():
  function ex3_model (line 138) | def ex3_model(mfnum=7):
  function ex3_f (line 155) | def ex3_f(u):
  function ex3_training_data (line 166) | def ex3_training_data(batch_size=1024):
  function ex3_u (line 177) | def ex3_u(k):
  function ex3_testing_data (line 193) | def ex3_testing_data():
  function ex4_model (line 204) | def ex4_model():
  function jang_ex4_trained_model (line 221) | def jang_ex4_trained_model():
  function jang_ex4_data (line 268) | def jang_ex4_data(filename):

FILE: jang_inverse_example.py
  function random_u (line 26) | def random_u(steps):
  function y_next (line 31) | def y_next(k, y, u):
  function make_plant_seq (line 42) | def make_plant_seq(steps, u):
  function get_training (line 50) | def get_training(size=100, and_plot=True):
  function make_training_data (line 65) | def make_training_data(size=100):
  function plant_model_untrained (line 76) | def plant_model_untrained():
  function u_next (line 94) | def u_next(model, y_now, y_next):
  function run_plant_trained (line 103) | def run_plant_trained(steps, model, y_desired, y_init=0.0):
  function make_y_desired (line 118) | def make_y_desired(size=100):
  function test_control_model (line 127) | def test_control_model(model, size=300, and_plot=True):

FILE: jang_pendulum_example.py
  class Pendulum (line 29) | class Pendulum():
    method __init__ (line 35) | def __init__(self, theta=0, dtheta=0):
    method theta (line 48) | def theta(self):
    method dtheta (line 52) | def dtheta(self):
    method state (line 56) | def state(self):
    method state (line 60) | def state(self, new_state):
    method _theta_dot_dot_radians (line 63) | def _theta_dot_dot_radians(self, rtheta, rdtheta, force):
    method theta_dot_dot (line 76) | def theta_dot_dot(self, force):
    method take_step (line 85) | def take_step(self, force, h=10e-3):
  function initial_anfis (line 97) | def initial_anfis():
  function jang_traned_anfis (line 113) | def jang_traned_anfis():
  class PendulumSystem (line 134) | class PendulumSystem(torch.nn.Module):
    method __init__ (line 140) | def __init__(self, theta=0, dtheta=0):
    method forward (line 146) | def forward(self, x):
  function loss_from (line 168) | def loss_from(trajectory, desired_trajectory, lam=10):
  function loss_from_upright (line 183) | def loss_from_upright(trajectory, lam=10):
  function plot_errors (line 194) | def plot_errors(errors):
  function plot_thetas (line 204) | def plot_thetas(x_data, y_pred):
  function train_pendulum (line 222) | def train_pendulum(model, x_data, optimizer,

FILE: membership.py
  function _mk_param (line 13) | def _mk_param(val):
  class GaussMembFunc (line 20) | class GaussMembFunc(torch.nn.Module):
    method __init__ (line 26) | def __init__(self, mu, sigma):
    method forward (line 31) | def forward(self, x):
    method pretty (line 35) | def pretty(self):
  function make_gauss_mfs (line 39) | def make_gauss_mfs(sigma, mu_list):
  class BellMembFunc (line 44) | class BellMembFunc(torch.nn.Module):
    method __init__ (line 51) | def __init__(self, a, b, c):
    method b_log_hook (line 59) | def b_log_hook(grad):
    method forward (line 67) | def forward(self, x):
    method pretty (line 71) | def pretty(self):
  function make_bell_mfs (line 75) | def make_bell_mfs(a, b, clist):
  class TriangularMembFunc (line 80) | class TriangularMembFunc(torch.nn.Module):
    method __init__ (line 87) | def __init__(self, a, b, c):
    method isosceles (line 96) | def isosceles(width, center):
    method forward (line 102) | def forward(self, x):
    method pretty (line 112) | def pretty(self):
  function make_tri_mfs (line 116) | def make_tri_mfs(width, clist):
  class TrapezoidalMembFunc (line 121) | class TrapezoidalMembFunc(torch.nn.Module):
    method __init__ (line 131) | def __init__(self, a, b, c, d):
    method symmetric (line 141) | def symmetric(topwidth, slope, midpt):
    method rectangle (line 153) | def rectangle(left, right):
    method triangle (line 160) | def triangle(left, midpt, right):
    method forward (line 167) | def forward(self, x):
    method pretty (line 180) | def pretty(self):
  function make_trap_mfs (line 185) | def make_trap_mfs(width, slope, clist):
  function make_anfis (line 199) | def make_anfis(x, num_mfs=5, num_out=1, hybrid=True):

FILE: sk_examples.py
  class FittingCallback (line 26) | class FittingCallback(Callback):
    method __init__ (line 32) | def __init__(self):
    method on_epoch_end (line 35) | def on_epoch_end(self, net, dataset_train=None,
  class MySimpleNet (line 51) | class MySimpleNet(nn.Module):
    method __init__ (line 56) | def __init__(self, num_in, num_feat, num_hidden=10, nonlin=F.relu):
    method forward (line 64) | def forward(self, X, **kwargs):
  function train_simple_nn (line 72) | def train_simple_nn(X, y, num_in, num_feat):
  function fuzzy_classifier (line 84) | def fuzzy_classifier(num_in, num_mfs=5):
  function train_fuzzy (line 97) | def train_fuzzy(model, X, y, show_plots=True):
  function classify_example (line 116) | def classify_example():
  function test_jang (line 131) | def test_jang(show_plots=True):
  function test_vignette (line 158) | def test_vignette(show_plots=True):

FILE: vignette_examples.py
  function vignette_ex1 (line 22) | def vignette_ex1():
  function vignette_ex2 (line 36) | def vignette_ex2():
  function vignette_ex3 (line 50) | def vignette_ex3():
  function vignette_ex3a (line 64) | def vignette_ex3a():
  function vignette_ex3b (line 77) | def vignette_ex3b():
  function vignette_ex5 (line 90) | def vignette_ex5():
  function vignette_ex1_trained (line 105) | def vignette_ex1_trained():
  function vignette_ex5_trained (line 148) | def vignette_ex5_trained():