SYMBOL INDEX (620 symbols across 88 files)

FILE: cpp/autograd/autograd.cpp
  function basic_autograd_operations_example (line 6) | void basic_autograd_operations_example() {
  function compute_higher_order_gradients_example (line 82) | void compute_higher_order_gradients_example() {
  class LinearFunction (line 110) | class LinearFunction : public Function<LinearFunction> {
    method forward (line 115) | static torch::Tensor forward(
    method tensor_list (line 125) | static tensor_list backward(AutogradContext *ctx, tensor_list grad_out...
  class MulConstant (line 143) | class MulConstant : public Function<MulConstant> {
    method forward (line 145) | static torch::Tensor forward(AutogradContext *ctx, torch::Tensor tenso...
    method tensor_list (line 152) | static tensor_list backward(AutogradContext *ctx, tensor_list grad_out...
  function custom_autograd_function_example (line 159) | void custom_autograd_function_example() {
  function main (line 179) | int main() {

FILE: cpp/custom-dataset/custom-dataset.cpp
  type Options (line 10) | struct Options {
  class CustomDataset (line 26) | class CustomDataset : public torch::data::datasets::Dataset<CustomDatase...
    method CustomDataset (line 32) | CustomDataset(const Data& data) : data(data) {}
    method Example (line 34) | Example get(size_t index) {
    method size (line 63) | torch::optional<size_t> size() const {
  function readInfo (line 68) | std::pair<Data, Data> readInfo() {
  type NetworkImpl (line 98) | struct NetworkImpl : torch::nn::SequentialImpl {
    method NetworkImpl (line 99) | NetworkImpl() {
  function train (line 132) | void train(
  function test (line 169) | void test(Network& network, DataLoader& loader, size_t data_size) {
  function main (line 193) | int main() {

FILE: cpp/dcgan/dcgan.cpp
  type DCGANGeneratorImpl (line 31) | struct DCGANGeneratorImpl : nn::Module {
    method DCGANGeneratorImpl (line 32) | DCGANGeneratorImpl(int kNoiseSize)
    method forward (line 61) | torch::Tensor forward(torch::Tensor x) {
  function create_discriminator (line 75) | nn::Sequential create_discriminator() {
  function main (line 94) | int main(int argc, const char* argv[]) {

FILE: cpp/distributed/dist-mnist.cpp
  type Model (line 6) | struct Model : torch::nn::Module {
    method Model (line 7) | Model()
    method forward (line 19) | torch::Tensor forward(torch::Tensor x) {
  function waitWork (line 37) | void waitWork(
  function main (line 50) | int main(int argc, char* argv[]) {

FILE: cpp/mnist/mnist.cpp
  type Net (line 24) | struct Net : torch::nn::Module {
    method Net (line 25) | Net()
    method forward (line 37) | torch::Tensor forward(torch::Tensor x) {
  function train (line 56) | void train(
  function test (line 86) | void test(
  function main (line 115) | auto main() -> int {

FILE: cpp/regression/regression.cpp
  function make_features (line 10) | torch::Tensor make_features(torch::Tensor x) {
  function f (line 19) | torch::Tensor f(
  function poly_desc (line 27) | std::string poly_desc(torch::Tensor W, torch::Tensor b) {
  function get_batch (line 39) | std::pair<torch::Tensor, torch::Tensor> get_batch(
  function main (line 49) | int main() {

FILE: cpp/tools/download_mnist.py
  function report_download_progress (line 25) | def report_download_progress(chunk_number, chunk_size, file_size):
  function download (line 32) | def download(destination_path, url, quiet):
  function unzip (line 49) | def unzip(zipped_path, quiet):
  function main (line 62) | def main():

FILE: cpp/transfer-learning/classify.cpp
  function load_images (line 16) | std::vector<std::string> load_images(std::string folder_name) {
  function print_probabilities (line 33) | void print_probabilities(std::string loc, std::string model_path, std::s...
  function main (line 61) | int main(int arc, char** argv)

FILE: cpp/transfer-learning/main.cpp
  function read_data (line 10) | torch::Tensor read_data(std::string location) {
  function read_label (line 29) | torch::Tensor read_label(int label) {
  function process_images (line 44) | std::vector<torch::Tensor> process_images(std::vector<std::string> list_...
  function process_labels (line 63) | std::vector<torch::Tensor> process_labels(std::vector<int> list_labels) {
  function load_data_from_folder (line 82) | std::pair<std::vector<std::string>,std::vector<int>> load_data_from_fold...
  function train (line 123) | void train(torch::jit::script::Module net, torch::nn::Linear lin, Datalo...
  function test (line 192) | void test(torch::jit::script::Module network, torch::nn::Linear lin, Dat...
  function main (line 234) | int main(int argc, const char * argv[]) {

FILE: cpp/transfer-learning/main.h
  function class (line 43) | class CustomDataset : public torch::data::Dataset<CustomDataset> {

FILE: dcgan/main.py
  function weights_init (line 117) | def weights_init(m):
  class Generator (line 126) | class Generator(nn.Module):
    method __init__ (line 127) | def __init__(self, ngpu):
    method forward (line 153) | def forward(self, input):
  class Discriminator (line 169) | class Discriminator(nn.Module):
    method __init__ (line 170) | def __init__(self, ngpu):
    method forward (line 194) | def forward(self, input):

FILE: distributed/FSDP/T5_training.py
  function get_policies (line 47) | def get_policies(cfg, rank):
  function fsdp_main (line 76) | def fsdp_main(args):

FILE: distributed/FSDP/configs/fsdp.py
  class fsdp_config (line 7) | class fsdp_config:

FILE: distributed/FSDP/configs/training.py
  class train_config (line 6) | class train_config:

FILE: distributed/FSDP/model_checkpointing/checkpoint_handler.py
  function get_date_of_run (line 31) | def get_date_of_run():
  function load_model_sharded (line 44) | def load_model_sharded(model, rank, cfg, verbose=True):
  function save_model_and_optimizer_sharded (line 82) | def save_model_and_optimizer_sharded(model, rank, cfg,optim=None, verbos...
  function save_model_checkpoint (line 121) | def save_model_checkpoint(
  function load_model_checkpoint (line 159) | def load_model_checkpoint(model, rank, cfg, verbose=True):
  function save_optimizer_checkpoint (line 186) | def save_optimizer_checkpoint(model, optimizer, rank, cfg, epoch=1):
  function load_optimizer_checkpoint (line 215) | def load_optimizer_checkpoint(model, optimizer, rank, cfg):
  function load_distributed_model_checkpoint (line 244) | def load_distributed_model_checkpoint(model, rank, cfg):
  function save_distributed_model_checkpoint (line 278) | def save_distributed_model_checkpoint(model, rank, cfg, epoch=1):

FILE: distributed/FSDP/policies/activation_checkpointing_functions.py
  function apply_fsdp_checkpointing (line 23) | def apply_fsdp_checkpointing(model):

FILE: distributed/FSDP/policies/wrapping.py
  function get_size_policy (line 27) | def get_size_policy(min_params=1e8):
  function get_t5_wrapper (line 34) | def get_t5_wrapper():

FILE: distributed/FSDP/summarization_dataset.py
  class wikihow (line 26) | class wikihow(Dataset):
    method __init__ (line 27) | def __init__(self, tokenizer, type_path, num_samples, input_length, ou...
    method __len__ (line 36) | def __len__(self):
    method clean_text (line 39) | def clean_text(self, text):
    method convert_to_features (line 49) | def convert_to_features(self, example_batch):
    method __getitem__ (line 69) | def __getitem__(self, index):
  function get_dataset (line 80) | def get_dataset(tokenizer, type_path, num_samples, args):

FILE: distributed/FSDP/utils/environment.py
  function bfloat_support (line 20) | def bfloat_support():

FILE: distributed/FSDP/utils/train_utils.py
  function setup (line 11) | def setup():
  function cleanup (line 16) | def cleanup():
  function get_date_of_run (line 19) | def get_date_of_run():
  function format_metrics_to_gb (line 29) | def format_metrics_to_gb(item):
  function train (line 35) | def train(args, model, rank, world_size, train_loader, optimizer, epoch,...
  function validation (line 71) | def validation(model, rank, world_size, val_loader):
  function setup_model (line 99) | def setup_model(model_name):

FILE: distributed/FSDP2/checkpoint.py
  function get_latest_checkpoint_folder (line 23) | def get_latest_checkpoint_folder(path):
  class Checkpointer (line 39) | class Checkpointer:
    method __init__ (line 40) | def __init__(self, folder: str, dcp_api: bool):
    method is_empty (line 47) | def is_empty(self):
    method load_model (line 50) | def load_model(self, model: FSDPModule):
    method load_optim (line 81) | def load_optim(self, model: FSDPModule, opt: torch.optim.Optimizer):
    method _get_full_model_state_dict (line 136) | def _get_full_model_state_dict(self, model: FSDPModule):
    method _get_full_optimizer_state_dict (line 156) | def _get_full_optimizer_state_dict(
    method save (line 199) | def save(self, model: FSDPModule, optim: torch.optim.Optimizer):

FILE: distributed/FSDP2/example.py
  function verify_min_gpu_count (line 10) | def verify_min_gpu_count(min_gpus: int = 2) -> bool:
  function set_modules_to_forward_prefetch (line 16) | def set_modules_to_forward_prefetch(model, num_to_forward_prefetch):
  function set_modules_to_backward_prefetch (line 26) | def set_modules_to_backward_prefetch(model, num_to_backward_prefetch):
  function main (line 36) | def main(args):

FILE: distributed/FSDP2/model.py
  class ModelArgs (line 9) | class ModelArgs:
  class Attention (line 18) | class Attention(nn.Module):
    method __init__ (line 19) | def __init__(self, args: ModelArgs):
    method forward (line 32) | def forward(self, x):
    method reset_parameters (line 53) | def reset_parameters(self):
  class FeedForward (line 60) | class FeedForward(nn.Module):
    method __init__ (line 61) | def __init__(self, dim, hidden_dim, dropout_p):
    method forward (line 68) | def forward(self, x):
    method reset_parameters (line 71) | def reset_parameters(self):
  class TransformerBlock (line 76) | class TransformerBlock(nn.Module):
    method __init__ (line 77) | def __init__(self, args: ModelArgs):
    method forward (line 86) | def forward(self, x):
    method reset_parameters (line 91) | def reset_parameters(self):
  class Transformer (line 100) | class Transformer(nn.Module):
    method __init__ (line 101) | def __init__(self, args: ModelArgs):
    method forward (line 116) | def forward(self, tokens):
    method reset_parameters (line 130) | def reset_parameters(self):

FILE: distributed/FSDP2/utils.py
  function inspect_model (line 7) | def inspect_model(model: FSDPModule):
  function inspect_mixed_precision (line 20) | def inspect_mixed_precision(model: FSDPModule):

FILE: distributed/ddp-tutorial-series/datautils.py
  class MyTrainDataset (line 4) | class MyTrainDataset(Dataset):
    method __init__ (line 5) | def __init__(self, size):
    method __len__ (line 9) | def __len__(self):
    method __getitem__ (line 12) | def __getitem__(self, index):

FILE: distributed/ddp-tutorial-series/multigpu.py
  function ddp_setup (line 13) | def ddp_setup(rank, world_size):
  class Trainer (line 24) | class Trainer:
    method __init__ (line 25) | def __init__(
    method _run_batch (line 40) | def _run_batch(self, source, targets):
    method _run_epoch (line 47) | def _run_epoch(self, epoch):
    method _save_checkpoint (line 56) | def _save_checkpoint(self, epoch):
    method train (line 62) | def train(self, max_epochs: int):
  function load_train_objs (line 69) | def load_train_objs():
  function prepare_dataloader (line 76) | def prepare_dataloader(dataset: Dataset, batch_size: int):
  function main (line 86) | def main(rank: int, world_size: int, save_every: int, total_epochs: int,...

FILE: distributed/ddp-tutorial-series/multigpu_torchrun.py
  function ddp_setup (line 13) | def ddp_setup():
  class Trainer (line 17) | class Trainer:
    method __init__ (line 18) | def __init__(
    method _load_snapshot (line 39) | def _load_snapshot(self, snapshot_path):
    method _run_batch (line 46) | def _run_batch(self, source, targets):
    method _run_epoch (line 53) | def _run_epoch(self, epoch):
    method _save_snapshot (line 62) | def _save_snapshot(self, epoch):
    method train (line 70) | def train(self, max_epochs: int):
  function load_train_objs (line 77) | def load_train_objs():
  function prepare_dataloader (line 84) | def prepare_dataloader(dataset: Dataset, batch_size: int):
  function main (line 94) | def main(save_every: int, total_epochs: int, batch_size: int, snapshot_p...

FILE: distributed/ddp-tutorial-series/multinode.py
  function ddp_setup (line 13) | def ddp_setup():
  class Trainer (line 17) | class Trainer:
    method __init__ (line 18) | def __init__(
    method _load_snapshot (line 40) | def _load_snapshot(self, snapshot_path):
    method _run_batch (line 47) | def _run_batch(self, source, targets):
    method _run_epoch (line 54) | def _run_epoch(self, epoch):
    method _save_snapshot (line 63) | def _save_snapshot(self, epoch):
    method train (line 71) | def train(self, max_epochs: int):
  function load_train_objs (line 78) | def load_train_objs():
  function prepare_dataloader (line 85) | def prepare_dataloader(dataset: Dataset, batch_size: int):
  function main (line 95) | def main(save_every: int, total_epochs: int, batch_size: int, snapshot_p...

FILE: distributed/ddp-tutorial-series/single_gpu.py
  class Trainer (line 7) | class Trainer:
    method __init__ (line 8) | def __init__(
    method _run_batch (line 22) | def _run_batch(self, source, targets):
    method _run_epoch (line 29) | def _run_epoch(self, epoch):
    method _save_checkpoint (line 37) | def _save_checkpoint(self, epoch):
    method train (line 43) | def train(self, max_epochs: int):
  function load_train_objs (line 50) | def load_train_objs():
  function prepare_dataloader (line 57) | def prepare_dataloader(dataset: Dataset, batch_size: int):
  function main (line 66) | def main(device, total_epochs, save_every, batch_size):

FILE: distributed/ddp/example.py
  function verify_min_gpu_count (line 14) | def verify_min_gpu_count(min_gpus: int = 2) -> bool:
  class ToyModel (line 20) | class ToyModel(nn.Module):
    method __init__ (line 21) | def __init__(self):
    method forward (line 27) | def forward(self, x):
  function demo_basic (line 31) | def demo_basic(rank):
  function main (line 53) | def main():

FILE: distributed/minGPT-ddp/mingpt/char_dataset.py
  class DataConfig (line 11) | class DataConfig:
  class CharDataset (line 17) | class CharDataset(Dataset):
    method __init__ (line 19) | def __init__(self, data_cfg: DataConfig): #data_path: str, block_size):
    method __len__ (line 33) | def __len__(self):
    method __getitem__ (line 36) | def __getitem__(self, idx):

FILE: distributed/minGPT-ddp/mingpt/main.py
  function verify_min_gpu_count (line 12) | def verify_min_gpu_count(min_gpus: int = 2) -> bool:
  function ddp_setup (line 17) | def ddp_setup():
  function get_train_objs (line 25) | def get_train_objs(gpt_cfg: GPTConfig, opt_cfg: OptimizerConfig, data_cf...
  function main (line 38) | def main(cfg: DictConfig):

FILE: distributed/minGPT-ddp/mingpt/model.py
  class GPTConfig (line 15) | class GPTConfig:
  class OptimizerConfig (line 30) | class OptimizerConfig:
  class MultiheadAttentionLayer (line 34) | class MultiheadAttentionLayer(nn.Module):
    method __init__ (line 39) | def __init__(self, config, device="cpu", dtype=torch.float32):
    method forward (line 55) | def forward(self, x):
  class Block (line 61) | class Block(nn.Module):
    method __init__ (line 63) | def __init__(self, config: GPTConfig):
    method forward (line 75) | def forward(self, x):
  class EmbeddingStem (line 80) | class EmbeddingStem(nn.Module):
    method __init__ (line 81) | def __init__(self, config: GPTConfig, device="cpu", dtype=torch.float32):
    method reset_parameters (line 88) | def reset_parameters(self):
    method forward (line 91) | def forward(self, idx):
  class GPT (line 99) | class GPT(nn.Module):
    method __init__ (line 102) | def __init__(self, config: GPTConfig):
    method _set_model_config (line 125) | def _set_model_config(self, config):
    method _init_weights (line 150) | def _init_weights(self, module):
    method forward (line 159) | def forward(self, idx, targets=None):
    method generate (line 173) | def generate(self, idx, max_new_tokens, temperature=1.0, do_sample=Fal...
  function create_optimizer (line 203) | def create_optimizer(model: torch.nn.Module, opt_config: OptimizerConfig):

FILE: distributed/minGPT-ddp/mingpt/trainer.py
  class TrainerConfig (line 22) | class TrainerConfig:
  class Snapshot (line 32) | class Snapshot:
  function upload_to_s3 (line 37) | def upload_to_s3(obj, dst):
  class Trainer (line 44) | class Trainer:
    method __init__ (line 46) | def __init__(self, trainer_config: TrainerConfig, model, optimizer, tr...
    method _prepare_dataloader (line 73) | def _prepare_dataloader(self, dataset: Dataset):
    method _load_snapshot (line 83) | def _load_snapshot(self):
    method _run_batch (line 99) | def _run_batch(self, source, targets, train: bool = True) -> float:
    method _run_epoch (line 117) | def _run_epoch(self, epoch: int, dataloader: DataLoader, train: bool =...
    method _save_snapshot (line 128) | def _save_snapshot(self, epoch):
    method train (line 146) | def train(self):

FILE: distributed/rpc/batch/parameter_server.py
  function timed_log (line 27) | def timed_log(text):
  class BatchUpdateParameterServer (line 31) | class BatchUpdateParameterServer(object):
    method __init__ (line 33) | def __init__(self, batch_update_size=batch_update_size):
    method get_model (line 43) | def get_model(self):
    method update_and_fetch_model (line 48) | def update_and_fetch_model(ps_rref, grads):
  class Trainer (line 70) | class Trainer(object):
    method __init__ (line 72) | def __init__(self, ps_rref):
    method get_next_batch (line 79) | def get_next_batch(self):
    method train (line 86) | def train(self):
  function run_trainer (line 101) | def run_trainer(ps_rref):
  function run_ps (line 106) | def run_ps(trainers):
  function run (line 119) | def run(rank, world_size):

FILE: distributed/rpc/batch/reinforce.py
  class Policy (line 40) | class Policy(nn.Module):
    method __init__ (line 46) | def __init__(self, batch=True):
    method forward (line 53) | def forward(self, x):
  class Observer (line 61) | class Observer:
    method __init__ (line 74) | def __init__(self, batch=True):
    method run_episode (line 80) | def run_episode(self, agent_rref, n_steps):
  class Agent (line 119) | class Agent:
    method __init__ (line 120) | def __init__(self, world_size, batch=True):
    method select_action_batch (line 146) | def select_action_batch(agent_rref, ob_id, state):
    method select_action (line 173) | def select_action(agent_rref, ob_id, state):
    method run_episode (line 184) | def run_episode(self, n_steps=0):
  function run_worker (line 220) | def run_worker(rank, world_size, n_episode, batch, print_log=True):
  function main (line 244) | def main():

FILE: distributed/rpc/ddp_rpc/main.py
  function verify_min_gpu_count (line 18) | def verify_min_gpu_count(min_gpus: int = 2) -> bool:
  class HybridModel (line 24) | class HybridModel(torch.nn.Module):
    method __init__ (line 32) | def __init__(self, remote_emb_module, rank):
    method forward (line 38) | def forward(self, indices, offsets):
  function _run_trainer (line 43) | def _run_trainer(remote_emb_module, rank):
  function run_worker (line 113) | def run_worker(rank, world_size):

FILE: distributed/rpc/parameter_server/rpc_parameter_server.py
  class Net (line 18) | class Net(nn.Module):
    method __init__ (line 19) | def __init__(self, num_gpus=0):
    method forward (line 43) | def forward(self, x):
  function call_method (line 68) | def call_method(method, rref, *args, **kwargs):
  function remote_method (line 79) | def remote_method(method, rref, *args, **kwargs):
  class ParameterServer (line 84) | class ParameterServer(nn.Module):
    method __init__ (line 85) | def __init__(self, num_gpus=0):
    method forward (line 95) | def forward(self, inp):
    method get_dist_gradients (line 105) | def get_dist_gradients(self, cid):
    method get_param_rrefs (line 117) | def get_param_rrefs(self):
  function get_parameter_server (line 124) | def get_parameter_server(num_gpus=0):
  function run_parameter_server (line 134) | def run_parameter_server(rank, world_size):
  class TrainerNet (line 152) | class TrainerNet(nn.Module):
    method __init__ (line 153) | def __init__(self, num_gpus=0):
    method get_global_param_rrefs (line 159) | def get_global_param_rrefs(self):
    method forward (line 165) | def forward(self, x):
  function run_training_loop (line 171) | def run_training_loop(rank, num_gpus, train_loader, test_loader):
  function get_accuracy (line 199) | def get_accuracy(test_loader, model):
  function run_worker (line 220) | def run_worker(rank, world_size, num_gpus, train_loader, test_loader):

FILE: distributed/rpc/pipeline/main.py
  function conv1x1 (line 39) | def conv1x1(in_planes, out_planes, stride=1):
  class ResNetBase (line 43) | class ResNetBase(nn.Module):
    method __init__ (line 44) | def __init__(self, block, inplanes, num_classes=1000,
    method _make_layer (line 56) | def _make_layer(self, planes, blocks, stride=1):
    method parameter_rrefs (line 77) | def parameter_rrefs(self):
  class ResNetShard1 (line 85) | class ResNetShard1(ResNetBase):
    method __init__ (line 89) | def __init__(self, device, *args, **kwargs):
    method forward (line 110) | def forward(self, x_rref):
  class ResNetShard2 (line 117) | class ResNetShard2(ResNetBase):
    method __init__ (line 121) | def __init__(self, device, *args, **kwargs):
    method forward (line 134) | def forward(self, x_rref):
  class DistResNet50 (line 141) | class DistResNet50(nn.Module):
    method __init__ (line 145) | def __init__(self, split_size, workers, *args, **kwargs):
    method forward (line 166) | def forward(self, xs):
    method parameter_rrefs (line 179) | def parameter_rrefs(self):
  function create_optimizer_for_remote_params (line 196) | def create_optimizer_for_remote_params(worker_name, param_rrefs, lr=0.05):
  function run_master (line 204) | def run_master(split_size):
  function run_worker (line 251) | def run_worker(rank, world_size, num_split):

FILE: distributed/rpc/rl/main.py
  function _call_method (line 34) | def _call_method(method, rref, *args, **kwargs):
  function _remote_method (line 41) | def _remote_method(method, rref, *args, **kwargs):
  class Policy (line 50) | class Policy(nn.Module):
    method __init__ (line 56) | def __init__(self):
    method forward (line 65) | def forward(self, x):
  class Observer (line 72) | class Observer:
    method __init__ (line 85) | def __init__(self):
    method run_episode (line 90) | def run_episode(self, agent_rref, n_steps):
  class Agent (line 112) | class Agent:
    method __init__ (line 113) | def __init__(self, world_size):
    method select_action (line 129) | def select_action(self, ob_id, state):
    method report_reward (line 146) | def report_reward(self, ob_id, reward):
    method run_episode (line 152) | def run_episode(self, n_steps=0):
    method finish_episode (line 171) | def finish_episode(self):
  function run_worker (line 210) | def run_worker(rank, world_size):
  function main (line 241) | def main():

FILE: distributed/rpc/rnn/main.py
  function _run_trainer (line 13) | def _run_trainer():
  function run_worker (line 65) | def run_worker(rank, world_size):

FILE: distributed/rpc/rnn/rnn.py
  function _call_method (line 7) | def _call_method(method, rref, *args, **kwargs):
  function _remote_method (line 14) | def _remote_method(method, rref, *args, **kwargs):
  function _parameter_rrefs (line 27) | def _parameter_rrefs(module):
  class EmbeddingTable (line 38) | class EmbeddingTable(nn.Module):
    method __init__ (line 42) | def __init__(self, ntoken, ninp, dropout):
    method forward (line 51) | def forward(self, input):
  class Decoder (line 58) | class Decoder(nn.Module):
    method __init__ (line 62) | def __init__(self, ntoken, nhid, dropout):
    method forward (line 69) | def forward(self, output):
  class RNNModel (line 73) | class RNNModel(nn.Module):
    method __init__ (line 80) | def __init__(self, ps, ntoken, ninp, nhid, nlayers, dropout=0.5):
    method forward (line 90) | def forward(self, input, hidden):
    method parameter_rrefs (line 98) | def parameter_rrefs(self):

FILE: distributed/tensor_parallelism/llama2_model.py
  class ModelArgs (line 13) | class ModelArgs:
  function precompute_freqs_cis (line 30) | def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
  function reshape_for_broadcast (line 53) | def reshape_for_broadcast(freqs_cis: torch.Tensor, x: torch.Tensor):
  function apply_rotary_emb (line 74) | def apply_rotary_emb(
  function repeat_kv (line 103) | def repeat_kv(x: torch.Tensor, n_rep: int) -> torch.Tensor:
  class RMSNorm (line 115) | class RMSNorm(nn.Module):
    method __init__ (line 129) | def __init__(self, dim: int, eps: float = 1e-6):
    method _norm (line 134) | def _norm(self, x: torch.Tensor):
    method forward (line 137) | def forward(self, x: torch.Tensor):
    method reset_parameters (line 141) | def reset_parameters(self):
  class Attention (line 145) | class Attention(nn.Module):
    method __init__ (line 165) | def __init__(self, model_args: ModelArgs):
    method init_weights (line 185) | def init_weights(self, init_std: float):
    method forward (line 190) | def forward(
  class FeedForward (line 231) | class FeedForward(nn.Module):
    method __init__ (line 248) | def __init__(
    method forward (line 266) | def forward(self, x):
    method init_weights (line 269) | def init_weights(self, init_std: float):
  class TransformerBlock (line 275) | class TransformerBlock(nn.Module):
    method __init__ (line 295) | def __init__(self, layer_id: int, model_args: ModelArgs):
    method forward (line 321) | def forward(
    method init_weights (line 341) | def init_weights(self):
  class Transformer (line 348) | class Transformer(nn.Module):
    method __init__ (line 367) | def __init__(self, model_args: ModelArgs):
    method init_weights (line 395) | def init_weights(self):
    method forward (line 428) | def forward(self, tokens: torch.Tensor):
    method from_model_args (line 451) | def from_model_args(cls, model_args: ModelArgs) -> "Transformer":

FILE: distributed/tensor_parallelism/log_utils.py
  function get_logger (line 8) | def get_logger():
  function rank_log (line 12) | def rank_log(_rank, logger, msg):
  function verify_min_gpu_count (line 18) | def verify_min_gpu_count(min_gpus: int = 2) -> bool:

FILE: distributed/tensor_parallelism/sequence_parallel_example.py
  class ToyModel (line 47) | class ToyModel(nn.Module):
    method __init__ (line 50) | def __init__(self):
    method forward (line 56) | def forward(self, x):

FILE: distributed/tensor_parallelism/tensor_parallel_example.py
  class ToyModel (line 57) | class ToyModel(nn.Module):
    method __init__ (line 60) | def __init__(self):
    method forward (line 66) | def forward(self, x):

FILE: fast_neural_style/download_saved_models.py
  function unzip (line 21) | def unzip(source_filename, dest_dir):

FILE: fast_neural_style/neural_style/neural_style.py
  function check_paths (line 20) | def check_paths(args):
  function train (line 31) | def train(args):
  function stylize (line 127) | def stylize(args):
  function stylize_onnx (line 166) | def stylize_onnx(content_image, args):
  function main (line 191) | def main():

FILE: fast_neural_style/neural_style/transformer_net.py
  class TransformerNet (line 4) | class TransformerNet(torch.nn.Module):
    method __init__ (line 5) | def __init__(self):
    method forward (line 29) | def forward(self, X):
  class ConvLayer (line 44) | class ConvLayer(torch.nn.Module):
    method __init__ (line 45) | def __init__(self, in_channels, out_channels, kernel_size, stride):
    method forward (line 51) | def forward(self, x):
  class ResidualBlock (line 57) | class ResidualBlock(torch.nn.Module):
    method __init__ (line 63) | def __init__(self, channels):
    method forward (line 71) | def forward(self, x):
  class UpsampleConvLayer (line 79) | class UpsampleConvLayer(torch.nn.Module):
    method __init__ (line 86) | def __init__(self, in_channels, out_channels, kernel_size, stride, ups...
    method forward (line 93) | def forward(self, x):

FILE: fast_neural_style/neural_style/utils.py
  function load_image (line 5) | def load_image(filename, size=None, scale=None):
  function save_image (line 14) | def save_image(filename, data):
  function gram_matrix (line 21) | def gram_matrix(y):
  function normalize_batch (line 29) | def normalize_batch(batch):

FILE: fast_neural_style/neural_style/vgg.py
  class Vgg16 (line 7) | class Vgg16(torch.nn.Module):
    method __init__ (line 8) | def __init__(self, requires_grad=False):
    method forward (line 27) | def forward(self, X):

FILE: fx/custom_tracer.py
  class M1 (line 45) | class M1(torch.nn.Module):
    method __init__ (line 46) | def __init__(self):
    method forward (line 50) | def forward(self, x):
  class LowerReluTracer (line 66) | class LowerReluTracer(Tracer):
    method is_leaf_module (line 67) | def is_leaf_module(self, m : torch.nn.Module, qualname : str):
  class M2 (line 94) | class M2(torch.nn.Module):
    method forward (line 95) | def forward(self, a, b):
  class TaggingTracer (line 98) | class TaggingTracer(Tracer):
    method create_node (line 99) | def create_node(self, kind : str, target : Union[str, Callable],
  function assert_all_nodes_have_tags (line 108) | def assert_all_nodes_have_tags(g: Graph) -> bool:

FILE: fx/inline_function.py
  class M (line 31) | class M(torch.nn.Module):
    method __init__ (line 32) | def __init__(self):
    method forward (line 36) | def forward(self, x):

FILE: fx/invert.py
  function add_inverse (line 9) | def add_inverse(a, b):
  function invert (line 26) | def invert(model: torch.nn.Module) -> torch.nn.Module:
  function f (line 51) | def f(x):

FILE: fx/module_tracer.py
  class ModulePathTracer (line 15) | class ModulePathTracer(torch.fx.Tracer):
    method call_module (line 30) | def call_module(self, m: torch.nn.Module, forward: Callable[..., Any],
    method create_proxy (line 50) | def create_proxy(self, kind: str, target: torch.fx.node.Target, args: ...

FILE: fx/native_interpreter/interpreter.cpp
  type ElementwiseInterpreter (line 9) | struct ElementwiseInterpreter : torch::CustomClassHolder {
    method ElementwiseInterpreter (line 14) | ElementwiseInterpreter() {}
    method setInstructions (line 20) | void setInstructions(std::vector<InstructionType> instructions) {
    method addConstant (line 27) | void addConstant(const std::string &name, at::Tensor value) {
    method setInputNames (line 35) | void setInputNames(std::vector<std::string> input_names) {
    method setOutputName (line 42) | void setOutputName(std::string output_name) {
    method __call__ (line 48) | at::Tensor __call__(std::vector<at::Tensor> inputs) {
    method SerializationType (line 138) | SerializationType __getstate__() const {
    method __setstate__ (line 145) | static c10::intrusive_ptr<ElementwiseInterpreter>
  function TORCH_LIBRARY (line 162) | TORCH_LIBRARY(NativeInterpretation, m) {

FILE: fx/native_interpreter/use_interpreter.py
  function lower_to_elementwise_interpreter (line 19) | def lower_to_elementwise_interpreter(orig_mod : torch.nn.Module) -> torc...
  class MyElementwiseModule (line 114) | class MyElementwiseModule(torch.nn.Module):
    method forward (line 115) | def forward(self, x, y):

FILE: fx/primitive_library.py
  function sigmoid_lowp (line 22) | def sigmoid_lowp(x : torch.Tensor):
  function add_lowp (line 34) | def add_lowp(a : torch.Tensor, b : torch.Tensor):
  class Foo (line 45) | class Foo(torch.nn.Module):
    method forward (line 46) | def forward(self, x, y):
  function inline_lowp_func (line 70) | def inline_lowp_func(n : torch.fx.Node):
  class InliningTracer (line 124) | class InliningTracer(torch.fx.Tracer):
    method create_node (line 127) | def create_node(self, kind, target, args, kwargs, name=None, type_expr...

FILE: fx/profiling_tracer.py
  class Foo (line 16) | class Foo(torch.nn.Module):
    method forward (line 17) | def forward(self, x):
  class ProfilerTracer (line 65) | class ProfilerTracer(torch.fx.Tracer):
    method trace (line 66) | def trace(self, root, concrete_args=None):

FILE: fx/replace_op.py
  class M (line 32) | class M(torch.nn.Module):
    method forward (line 33) | def forward(self, x, y):

FILE: fx/subgraph_rewriter_basic_use.py
  class M (line 29) | class M(torch.nn.Module):
    method __init__ (line 30) | def __init__(self):
    method forward (line 33) | def forward(self, x, w1, w2):
  function pattern (line 51) | def pattern(a1, a2):
  function replacement (line 56) | def replacement(w1, w2):

FILE: fx/wrap_output_dynamically.py
  class M (line 21) | class M(torch.nn.Module):
    method __init__ (line 22) | def __init__(self):
    method forward (line 25) | def forward(self, x, y):
  class ActivationFunction (line 33) | class ActivationFunction(Enum):
  function wrap_in_activation_function (line 45) | def wrap_in_activation_function(m: GraphModule, fn: ActivationFunction) ...

FILE: gat/main.py
  class GraphAttentionLayer (line 18) | class GraphAttentionLayer(nn.Module):
    method __init__ (line 32) | def __init__(self, in_features: int, out_features: int, n_heads: int, ...
    method reset_parameters (line 59) | def reset_parameters(self):
    method _get_attention_scores (line 67) | def _get_attention_scores(self, h_transformed: torch.Tensor):
    method forward (line 92) | def forward(self,  h: torch.Tensor, adj_mat: torch.Tensor):
  class GAT (line 143) | class GAT(nn.Module):
    method __init__ (line 149) | def __init__(self,
    method forward (line 184) | def forward(self, input_tensor: torch.Tensor , adj_mat: torch.Tensor):
  function load_cora (line 209) | def load_cora(path='./cora', device='cpu'):
  function train_iter (line 256) | def train_iter(epoch, model, optimizer, criterion, input, target, mask_t...
  function test (line 277) | def test(model, criterion, input, target, mask):

FILE: gcn/main.py
  class GraphConv (line 14) | class GraphConv(nn.Module):
    method __init__ (line 33) | def __init__(self, input_dim, output_dim, use_bias=False):
    method forward (line 46) | def forward(self, input_tensor, adj_mat):
  class GCN (line 67) | class GCN(nn.Module):
    method __init__ (line 79) | def __init__(self, input_dim, hidden_dim, output_dim, use_bias=True, d...
    method forward (line 89) | def forward(self, input_tensor, adj_mat):
  function load_cora (line 115) | def load_cora(path='./cora', device='cpu'):
  function train_iter (line 168) | def train_iter(epoch, model, optimizer, criterion, input, target, mask_t...
  function test (line 189) | def test(model, criterion, input, target, mask):

FILE: imagenet/main.py
  function main (line 86) | def main():
  function main_worker (line 137) | def main_worker(gpu, ngpus_per_node, args):
  function train (line 309) | def train(train_loader, model, criterion, optimizer, epoch, device, args):
  function validate (line 358) | def validate(val_loader, model, criterion, args):
  function save_checkpoint (line 429) | def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
  class Summary (line 434) | class Summary(Enum):
  class AverageMeter (line 440) | class AverageMeter(object):
    method __init__ (line 442) | def __init__(self, name, use_accel, fmt=':f', summary_type=Summary.AVE...
    method reset (line 449) | def reset(self):
    method update (line 455) | def update(self, val, n=1):
    method all_reduce (line 461) | def all_reduce(self):
    method __str__ (line 471) | def __str__(self):
    method summary (line 475) | def summary(self):
  class ProgressMeter (line 491) | class ProgressMeter(object):
    method __init__ (line 492) | def __init__(self, num_batches, meters, prefix=""):
    method display (line 497) | def display(self, batch):
    method display_summary (line 502) | def display_summary(self):
    method _get_batch_fmtstr (line 507) | def _get_batch_fmtstr(self, num_batches):
  function accuracy (line 512) | def accuracy(output, target, topk=(1,)):

FILE: language_translation/main.py
  function greedy_decode (line 17) | def greedy_decode(model, src, src_mask, max_len, start_symbol, end_symbol):
  function inference (line 53) | def inference(opts):
  function train (line 109) | def train(model, train_dl, loss_fn, optim, special_symbols, opts):
  function validate (line 153) | def validate(model, valid_dl, loss_fn, special_symbols):
  function main (line 184) | def main(opts):

FILE: language_translation/src/data.py
  function _yield_tokens (line 9) | def _yield_tokens(iterable_data, tokenizer, src):
  function get_data (line 19) | def get_data(opts):
  function generate_square_subsequent_mask (line 98) | def generate_square_subsequent_mask(size, device):
  function create_mask (line 104) | def create_mask(src, tgt, pad_idx, device):
  class Opts (line 122) | class Opts:
    method __init__ (line 123) | def __init__(self):

FILE: language_translation/src/model.py
  class PositionalEncoding (line 7) | class PositionalEncoding(nn.Module):
    method __init__ (line 8) | def __init__(
    method forward (line 25) | def forward(self, token_embedding):
  class Translator (line 28) | class Translator(nn.Module):
    method __init__ (line 29) | def __init__(
    method _init_weights (line 61) | def _init_weights(self):
    method forward (line 66) | def forward(self, src, trg, src_mask, tgt_mask, src_padding_mask, tgt_...
    method encode (line 84) | def encode(self, src, src_mask):
    method decode (line 92) | def decode(self, tgt, memory, tgt_mask):

FILE: legacy/snli/model.py
  class Bottle (line 5) | class Bottle(nn.Module):
    method forward (line 7) | def forward(self, input):
  class Linear (line 15) | class Linear(Bottle, nn.Linear):
  class Encoder (line 19) | class Encoder(nn.Module):
    method __init__ (line 21) | def __init__(self, config):
    method forward (line 30) | def forward(self, inputs):
  class SNLIClassifier (line 38) | class SNLIClassifier(nn.Module):
    method __init__ (line 40) | def __init__(self, config):
    method forward (line 64) | def forward(self, batch):

FILE: legacy/snli/util.py
  function makedirs (line 4) | def makedirs(name):
  function get_args (line 21) | def get_args():

FILE: mnist/main.py
  class Net (line 10) | class Net(nn.Module):
    method __init__ (line 11) | def __init__(self):
    method forward (line 20) | def forward(self, x):
  function train (line 36) | def train(args, model, device, train_loader, optimizer, epoch):
  function test (line 53) | def test(model, device, test_loader):
  function main (line 72) | def main():

FILE: mnist_forward_forward/main.py
  function get_y_neg (line 14) | def get_y_neg(y):
  function overlay_y_on_x (line 25) | def overlay_y_on_x(x, y, classes=10):
  class Net (line 32) | class Net(torch.nn.Module):
    method __init__ (line 33) | def __init__(self, dims):
    method predict (line 40) | def predict(self, x):
    method train (line 52) | def train(self, x_pos, x_neg):
  class Layer (line 59) | class Layer(nn.Linear):
    method __init__ (line 60) | def __init__(self, in_features, out_features, bias=True, device=None, ...
    method forward (line 67) | def forward(self, x):
    method train (line 71) | def train(self, x_pos, x_neg):

FILE: mnist_hogwild/main.py
  class Net (line 39) | class Net(nn.Module):
    method __init__ (line 40) | def __init__(self):
    method forward (line 48) | def forward(self, x):

FILE: mnist_hogwild/train.py
  function train (line 7) | def train(rank, args, model, device, dataset, dataloader_kwargs):
  function test (line 17) | def test(args, model, device, dataset, dataloader_kwargs):
  function train_epoch (line 25) | def train_epoch(epoch, args, model, device, data_loader, optimizer):
  function test_epoch (line 42) | def test_epoch(model, device, data_loader):

FILE: mnist_rnn/main.py
  class Net (line 13) | class Net(nn.Module):
    method __init__ (line 14) | def __init__(self):
    method forward (line 23) | def forward(self, input):
  function train (line 43) | def train(args, model, device, train_loader, optimizer, epoch):
  function test (line 60) | def test(args, model, device, test_loader):
  function main (line 81) | def main():

FILE: regression/main.py
  function make_features (line 13) | def make_features(x):
  function f (line 19) | def f(x):
  function poly_desc (line 24) | def poly_desc(W, b):
  function get_batch (line 33) | def get_batch(batch_size=32):

FILE: reinforcement_learning/actor_critic.py
  class Policy (line 36) | class Policy(nn.Module):
    method __init__ (line 40) | def __init__(self):
    method forward (line 54) | def forward(self, x):
  function select_action (line 78) | def select_action(state):
  function finish_episode (line 95) | def finish_episode():
  function main (line 138) | def main():

FILE: reinforcement_learning/reinforce.py
  class Policy (line 31) | class Policy(nn.Module):
    method __init__ (line 32) | def __init__(self):
    method forward (line 41) | def forward(self, x):
  function select_action (line 54) | def select_action(state):
  function finish_episode (line 63) | def finish_episode():
  function main (line 82) | def main():

FILE: siamese_network/main.py
  class SiameseNetwork (line 16) | class SiameseNetwork(nn.Module):
    method __init__ (line 27) | def __init__(self):
    method init_weights (line 54) | def init_weights(self, m):
    method forward_once (line 59) | def forward_once(self, x):
    method forward (line 64) | def forward(self, input1, input2):
  class APP_MATCHER (line 80) | class APP_MATCHER(Dataset):
    method __init__ (line 81) | def __init__(self, root, train, download=False):
    method group_examples (line 97) | def group_examples(self):
    method __len__ (line 115) | def __len__(self):
    method __getitem__ (line 118) | def __getitem__(self, index):
  function train (line 190) | def train(args, model, device, train_loader, optimizer, epoch):
  function test (line 211) | def test(model, device, test_loader):
  function main (line 237) | def main():

FILE: super_resolution/data.py
  function download_bsd300 (line 10) | def download_bsd300(dest="dataset"):
  function calculate_valid_crop_size (line 34) | def calculate_valid_crop_size(crop_size, upscale_factor):
  function input_transform (line 38) | def input_transform(crop_size, upscale_factor):
  function target_transform (line 46) | def target_transform(crop_size):
  function get_training_set (line 53) | def get_training_set(upscale_factor):
  function get_test_set (line 63) | def get_test_set(upscale_factor):

FILE: super_resolution/dataset.py
  function is_image_file (line 8) | def is_image_file(filename):
  function load_img (line 12) | def load_img(filepath):
  class DatasetFromFolder (line 18) | class DatasetFromFolder(data.Dataset):
    method __init__ (line 19) | def __init__(self, image_dir, input_transform=None, target_transform=N...
    method __getitem__ (line 26) | def __getitem__(self, index):
    method __len__ (line 36) | def __len__(self):

FILE: super_resolution/main.py
  function train (line 47) | def train(epoch):
  function test (line 63) | def test():
  function checkpoint (line 76) | def checkpoint(epoch):

FILE: super_resolution/model.py
  class Net (line 6) | class Net(nn.Module):
    method __init__ (line 7) | def __init__(self, upscale_factor):
    method forward (line 19) | def forward(self, x):
    method _initialize_weights (line 26) | def _initialize_weights(self):

FILE: time_sequence_prediction/train.py
  class Sequence (line 11) | class Sequence(nn.Module):
    method __init__ (line 12) | def __init__(self):
    method forward (line 18) | def forward(self, input, future = 0):
  function closure (line 61) | def closure():
  function draw (line 83) | def draw(yi, color):

FILE: vae/main.py
  class VAE (line 46) | class VAE(nn.Module):
    method __init__ (line 47) | def __init__(self):
    method encode (line 56) | def encode(self, x):
    method reparameterize (line 60) | def reparameterize(self, mu, logvar):
    method decode (line 65) | def decode(self, z):
    method forward (line 69) | def forward(self, x):
  function loss_function (line 80) | def loss_function(recon_x, x, mu, logvar):
  function train (line 92) | def train(epoch):
  function test (line 113) | def test(epoch):

FILE: word_language_model/data.py
  class Dictionary (line 5) | class Dictionary(object):
    method __init__ (line 6) | def __init__(self):
    method add_word (line 10) | def add_word(self, word):
    method __len__ (line 16) | def __len__(self):
  class Corpus (line 20) | class Corpus(object):
    method __init__ (line 21) | def __init__(self, path):
    method tokenize (line 27) | def tokenize(self, path):

FILE: word_language_model/main.py
  function batchify (line 85) | def batchify(data, bsz):
  function repackage_hidden (line 117) | def repackage_hidden(h):
  function get_batch (line 136) | def get_batch(source, i):
  function evaluate (line 143) | def evaluate(data_source):
  function train (line 163) | def train():
  function export_onnx (line 211) | def export_onnx(path, batch_size, seq_len):

FILE: word_language_model/model.py
  class RNNModel (line 6) | class RNNModel(nn.Module):
    method __init__ (line 9) | def __init__(self, rnn_type, ntoken, ninp, nhid, nlayers, dropout=0.5,...
    method init_weights (line 42) | def init_weights(self):
    method forward (line 48) | def forward(self, input, hidden):
    method init_hidden (line 56) | def init_hidden(self, bsz):
  class PositionalEncoding (line 65) | class PositionalEncoding(nn.Module):
    method __init__ (line 81) | def __init__(self, d_model, dropout=0.1, max_len=5000):
    method forward (line 93) | def forward(self, x):
  class TransformerModel (line 107) | class TransformerModel(nn.Transformer):
    method __init__ (line 110) | def __init__(self, ntoken, ninp, nhead, nhid, nlayers, dropout=0.5):
    method _generate_square_subsequent_mask (line 122) | def _generate_square_subsequent_mask(self, sz):
    method init_weights (line 125) | def init_weights(self):
    method forward (line 131) | def forward(self, src, has_mask=True):