code stringlengths 197 38.4k | apis list | extract_api stringlengths 137 20.3k |
|---|---|---|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from typing import Any, Optional, Tuple
import torch
import torch.distributed as dist
from colossalai.communication import all_gather, all_reduce, reduce_scatter
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.communication.all_gather",
"colossalai.communication.reduce_scatter",
"colossalai.core.global_context.get_group",
"colossalai.communication.all_reduce",
"colossalai.core.global_context.get_ranks_in_group"
] | [((462, 499), 'torch.cuda.amp.custom_fwd', 'custom_fwd', ([], {'cast_inputs': 'torch.float16'}), '(cast_inputs=torch.float16)\n', (472, 499), False, 'from torch.cuda.amp import custom_bwd, custom_fwd\n'), ((5920, 5957), 'torch.cuda.amp.custom_fwd', 'custom_fwd', ([], {'cast_inputs': 'torch.float16'}), '(cast_inputs=tor... |
import torch
from colossalai.tensor.op_wrapper import colo_op_impl
from colossalai.tensor import ColoTensor
@colo_op_impl(torch.nn.functional.cross_entropy)
def colo_cross_entropy(types, args=(), kwargs=None, pg=None):
arg_num = len(args)
if arg_num > 0:
input_tensor = args[0]
if arg_num > 1:
... | [
"colossalai.tensor.op_wrapper.colo_op_impl"
] | [((111, 158), 'colossalai.tensor.op_wrapper.colo_op_impl', 'colo_op_impl', (['torch.nn.functional.cross_entropy'], {}), '(torch.nn.functional.cross_entropy)\n', (123, 158), False, 'from colossalai.tensor.op_wrapper import colo_op_impl\n'), ((796, 859), 'torch.nn.functional.cross_entropy', 'torch.nn.functional.cross_ent... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import torch
try:
import colossal_C
except:
print('Colossalai should be built with cuda extension to use the FP16 optimizer')
from torch.optim import Optimizer
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context... | [
"colossalai.utils.print_rank_0",
"colossalai.logging.get_dist_logger",
"colossalai.utils.clip_grad_norm_fp32",
"colossalai.core.global_context.get_group",
"colossalai.utils.copy_tensor_parallel_attributes",
"colossalai.utils.count_zeros_fp32",
"colossalai.utils.multi_tensor_applier"
] | [((16274, 16289), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (16287, 16289), False, 'import torch\n'), ((1471, 1559), 'colossalai.utils.multi_tensor_applier', 'multi_tensor_applier', (['colossal_C.multi_tensor_scale', 'overflow_buf', '[this, that]', '(1.0)'], {}), '(colossal_C.multi_tensor_scale, overflow_buf,... |
#Adapted from https://github.com/hpcaitech/ColossalAI-Examples/blob/main/language/gpt/model/gpt1d.py
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import math
from colossalai.utils.activation_checkpoint import checkpoint
import torch
from torch import nn as nn, Tensor
from colossalai.core import global_conte... | [
"colossalai.utils.checkpoint",
"colossalai.nn.layer.Linear1D_Col",
"colossalai.nn.Dropout",
"colossalai.nn.layer.Linear1D_Row",
"colossalai.nn.layer.utils.divide"
] | [((1840, 1868), 'colossalai.nn.Dropout', 'col_nn.Dropout', (['dropout_prob'], {}), '(dropout_prob)\n', (1854, 1868), True, 'from colossalai import nn as col_nn\n'), ((2252, 2292), 'colossalai.utils.checkpoint', 'checkpoint', (['self._forward', 'hidden_states'], {}), '(self._forward, hidden_states)\n', (2262, 2292), Fal... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import os
from colossalai.constants import (DEPTH_3D, INPUT_GROUP_3D, OUTPUT_GROUP_3D,
WEIGHT_GROUP_3D)
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from torch import Tensor... | [
"colossalai.core.global_context.get_global_rank"
] | [((1522, 1543), 'colossalai.core.global_context.get_global_rank', 'gpc.get_global_rank', ([], {}), '()\n', (1541, 1543), True, 'from colossalai.core import global_context as gpc\n')] |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import os.path as osp
import pytest
from colossalai.context import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.initialize import initialize
from colossalai.logging import get_global_dist_logger
NUM_BATCH = 128
BATCH_SIZE = 32
SEQ_LE... | [
"colossalai.initialize.initialize",
"colossalai.core.global_context.is_last_rank",
"colossalai.core.global_context.destroy",
"colossalai.logging.get_global_dist_logger"
] | [((411, 470), 'os.path.join', 'osp.join', (['DIR_PATH', '"""../configs/pipeline_vanilla_resnet.py"""'], {}), "(DIR_PATH, '../configs/pipeline_vanilla_resnet.py')\n", (419, 470), True, 'import os.path as osp\n'), ((474, 548), 'pytest.mark.skip', 'pytest.mark.skip', (['"""This test should be invoked using the test.sh pro... |
import torch
import torch.distributed as dist
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import get_current_device
def send_tensor_meta(tensor, need_meta=True, next_rank=None):
"""Sends tensor meta information before sending a... | [
"colossalai.core.global_context.get_prev_global_rank",
"colossalai.core.global_context.get_local_rank",
"colossalai.utils.get_current_device",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.get_next_global_rank"
] | [((3203, 3247), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.PARALLEL_1D'], {}), '(ParallelMode.PARALLEL_1D)\n', (3221, 3247), True, 'from colossalai.core import global_context as gpc\n'), ((3260, 3279), 'torch.numel', 'torch.numel', (['tensor'], {}), '(tensor)\n', (3271, 3279)... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from typing import Any, Tuple
import torch
import torch.distributed as dist
from colossalai.communication import all_gather, reduce_scatter, scatter
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossal... | [
"colossalai.utils.empty_cache",
"colossalai.core.global_context.get_local_rank",
"colossalai.communication.all_gather",
"colossalai.communication.reduce_scatter",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_ranks_in_group"
] | [((991, 1004), 'colossalai.utils.empty_cache', 'empty_cache', ([], {}), '()\n', (1002, 1004), False, 'from colossalai.utils import empty_cache, get_current_device\n'), ((1171, 1216), 'colossalai.communication.all_gather', 'all_gather', (['A', 'input_dim', 'input_parallel_mode'], {}), '(A, input_dim, input_parallel_mode... |
import inspect
from pathlib import Path
from functools import partial
import torch
from torch.autograd.profiler import profile
import torch.distributed as dist
from torch.distributed import ReduceOp
from colossalai.utils import get_current_device
from .prof_utils import BaseProfiler, _format_time, _format_memor... | [
"colossalai.utils.get_current_device"
] | [((7912, 7938), 'torch.distributed.get_world_size', 'dist.get_world_size', (['group'], {}), '(group)\n', (7931, 7938), True, 'import torch.distributed as dist\n'), ((8639, 8665), 'torch.distributed.get_world_size', 'dist.get_world_size', (['group'], {}), '(group)\n', (8658, 8665), True, 'import torch.distributed as dis... |
import contextlib
import os
import colossalai
import torch
from colossalai.core import global_context as gpc
from colossalai.engine.schedule import (InterleavedPipelineSchedule, PipelineSchedule)
from colossalai.logging import get_dist_logger
from colossalai.nn import CosineAnnealingWarmupLR
from colossalai.t... | [
"colossalai.trainer.hooks.ThroughputHook",
"colossalai.trainer.Trainer",
"colossalai.trainer.hooks.LogMetricByStepHook",
"colossalai.trainer.hooks.LossHook",
"colossalai.logging.get_dist_logger",
"colossalai.initialize",
"colossalai.launch_from_torch",
"colossalai.utils.MultiTimer",
"colossalai.trai... | [((984, 1032), 'colossalai.launch_from_torch', 'colossalai.launch_from_torch', ([], {'config': 'args.config'}), '(config=args.config)\n', (1012, 1032), False, 'import colossalai\n'), ((1049, 1066), 'colossalai.logging.get_dist_logger', 'get_dist_logger', ([], {}), '()\n', (1064, 1066), False, 'from colossalai.logging i... |
import click
from .utils import *
from .benchmark import run_benchmark
from colossalai.context import Config
__all__ = ['benchmark']
@click.command()
@click.option("-g", "--gpus", type=int, default=None, help="Total number of devices to use.")
@click.option("-b", "--batch_size", type=int, default=8, help="Batch siz... | [
"colossalai.context.Config"
] | [((138, 153), 'click.command', 'click.command', ([], {}), '()\n', (151, 153), False, 'import click\n'), ((155, 252), 'click.option', 'click.option', (['"""-g"""', '"""--gpus"""'], {'type': 'int', 'default': 'None', 'help': '"""Total number of devices to use."""'}), "('-g', '--gpus', type=int, default=None, help=\n '... |
from functools import partial
import colossalai
import pytest
import torch
import torch.multiprocessing as mp
import torch.nn as nn
from colossalai.logging import get_dist_logger
from colossalai.testing import parameterize
from colossalai.utils import free_port
from colossalai.context import MOE_CONTEXT
fro... | [
"colossalai.launch",
"colossalai.logging.get_dist_logger",
"colossalai.utils.free_port",
"colossalai.testing.rerun_on_exception",
"colossalai.utils.get_current_device",
"colossalai.context.MOE_CONTEXT.setup",
"colossalai.nn.layer.MoeModule",
"colossalai.testing.parameterize"
] | [((1178, 1227), 'colossalai.testing.parameterize', 'parameterize', (['"""init_device_type"""', "['cpu', 'cuda']"], {}), "('init_device_type', ['cpu', 'cuda'])\n", (1190, 1227), False, 'from colossalai.testing import parameterize\n'), ((1230, 1320), 'colossalai.testing.parameterize', 'parameterize', (['"""shard_strategy... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from colossalai.context import ParallelMode
from colossalai.registry import HOOKS
from colossalai.utils import is_no_pp_or_last_stage
from ._base_hook import BaseHook
from ..metric import Loss, Accuracy1D, Accuracy2D, Accuracy, Accuracy2p5D, Accuracy3D
class MetricHook... | [
"colossalai.utils.is_no_pp_or_last_stage"
] | [((881, 905), 'colossalai.utils.is_no_pp_or_last_stage', 'is_no_pp_or_last_stage', ([], {}), '()\n', (903, 905), False, 'from colossalai.utils import is_no_pp_or_last_stage\n')] |
from typing import Any, Tuple
import torch
import torch.distributed as dist
from colossalai.communication.collective import (all_gather, all_reduce, reduce_scatter)
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import get_current_devic... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.communication.collective.reduce_scatter",
"colossalai.communication.collective.all_gather",
"colossalai.core.global_context.get_group",
"colossalai.communication.collective.all_reduce",
"colossalai.core.global_context.get_world_size",
"colossa... | [((463, 491), 'colossalai.core.global_context.get_group', 'gpc.get_group', (['parallel_mode'], {}), '(parallel_mode)\n', (476, 491), True, 'from colossalai.core import global_context as gpc\n'), ((528, 549), 'colossalai.core.global_context.get_global_rank', 'gpc.get_global_rank', ([], {}), '()\n', (547, 549), True, 'fr... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from typing import Optional, Tuple
import torch
from colossalai.communication import (all_gather, all_reduce, broadcast, reduce, reduce_scatter)
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from torch import... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.communication.all_gather",
"colossalai.communication.reduce_scatter",
"colossalai.communication.broadcast",
"colossalai.core.global_context.get_world_size",
"colossalai.communication.all_reduce",
"colossalai.core.global_context.get_ranks_in_gr... | [((558, 595), 'torch.cuda.amp.custom_fwd', 'custom_fwd', ([], {'cast_inputs': 'torch.float16'}), '(cast_inputs=torch.float16)\n', (568, 595), False, 'from torch.cuda.amp import custom_bwd, custom_fwd\n'), ((4642, 4679), 'torch.cuda.amp.custom_fwd', 'custom_fwd', ([], {'cast_inputs': 'torch.float16'}), '(cast_inputs=tor... |
import colossalai
import colossalai.nn as col_nn
import torch
from colossalai.context import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import get_current_device, print_rank_0
CONFIG = dict(parallel=dict(
data=1,
pipeline=1,
tensor=dict(size=8, mode='2.5d... | [
"colossalai.nn.Linear",
"colossalai.utils.print_rank_0",
"colossalai.launch",
"colossalai.core.global_context.get_local_rank",
"colossalai.utils.get_current_device",
"colossalai.logging.disable_existing_loggers",
"colossalai.launch_from_torch",
"colossalai.nn.Dropout",
"colossalai.get_default_parser... | [((1192, 1237), 'colossalai.logging.disable_existing_loggers', 'colossalai.logging.disable_existing_loggers', ([], {}), '()\n', (1235, 1237), False, 'import colossalai\n'), ((1252, 1283), 'colossalai.get_default_parser', 'colossalai.get_default_parser', ([], {}), '()\n', (1281, 1283), False, 'import colossalai\n'), ((1... |
import math
import torch
from torch import Tensor
from torch.nn import Parameter, init as init
from colossalai.context import seed, ParallelMode
from colossalai.core import global_context as gpc
from colossalai.registry import LAYERS
from colossalai.utils import get_current_device
from ._operation import Matmul_AB_2p... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.utils.get_current_device",
"colossalai.core.global_context.get_world_size",
"colossalai.context.seed",
"colossalai.core.global_context.get_group"
] | [((1595, 1645), 'colossalai.core.global_context.get_local_rank', 'gpc.get_local_rank', (['ParallelMode.PARALLEL_2P5D_COL'], {}), '(ParallelMode.PARALLEL_2P5D_COL)\n', (1613, 1645), True, 'from colossalai.core import global_context as gpc\n'), ((1670, 1720), 'colossalai.core.global_context.get_local_rank', 'gpc.get_loca... |
import copy
from functools import partial
import colossalai
import pytest
import torch
import torch.distributed as dist
import torch.multiprocessing as mp
from colossalai.utils import free_port
from colossalai.zero.shard_utils import (BucketTensorShardStrategy, TensorShardStrategy)
from colossalai.zero.sharded_model i... | [
"colossalai.launch",
"colossalai.utils.free_port",
"colossalai.zero.sharded_optim.ShardedOptimizerV2"
] | [((2680, 2725), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[1, 2]'], {}), "('world_size', [1, 2])\n", (2703, 2725), False, 'import pytest\n'), ((2727, 2780), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""cpu_offload"""', '[True, False]'], {}), "('cpu_offload', [True, Fals... |
import torch.nn.functional as F
from typing import Optional
from colossalai.tensor.op_wrapper import colo_op_impl
from colossalai.nn.layer.parallel_1d._utils import reduce_input, reduce_grad
from colossalai.tensor import ComputePattern, TensorSpec, ComputePattern, ParallelAction, ColoTensor, distspec
from colossalai.te... | [
"colossalai.tensor.ParallelAction",
"colossalai.tensor.graph.GraphGlobalEnv",
"colossalai.nn.layer.parallel_1d._utils.reduce_input",
"colossalai.tensor.op_wrapper.colo_op_impl",
"colossalai.tensor.graph.GraphOpNode",
"colossalai.nn.layer.parallel_1d._utils.reduce_grad"
] | [((2629, 2651), 'colossalai.tensor.op_wrapper.colo_op_impl', 'colo_op_impl', (['F.linear'], {}), '(F.linear)\n', (2641, 2651), False, 'from colossalai.tensor.op_wrapper import colo_op_impl\n'), ((872, 902), 'torch.nn.functional.linear', 'F.linear', (['input_tensor', 'weight'], {}), '(input_tensor, weight)\n', (880, 902... |
import torch
import torch.nn as nn
from torch.optim import Optimizer
from colossalai.amp.naive_amp import NaiveAMPModel
from colossalai.utils import is_no_pp_or_last_stage
from colossalai.core import global_context as gpc
from colossalai.context.parallel_mode import ParallelMode
from .zero_redundancy_optimizer_level_2... | [
"colossalai.core.global_context.get_group",
"colossalai.amp.naive_amp.NaiveAMPModel"
] | [((1194, 1236), 'colossalai.amp.naive_amp.NaiveAMPModel', 'NaiveAMPModel', (['model'], {'output_to_fp32': '(False)'}), '(model, output_to_fp32=False)\n', (1207, 1236), False, 'from colossalai.amp.naive_amp import NaiveAMPModel\n'), ((4624, 4656), 'colossalai.core.global_context.get_group', 'gpc.get_group', (['ParallelM... |
import functools
import torch
import types
from colossalai.utils.cuda import get_current_device
from colossalai.gemini.tensor_utils import colo_model_data_tensor_move_inline, colo_tensor_mem_usage
from colossalai.gemini.stateful_tensor import StatefulTensor, TensorState
from colossalai.gemini.tensor_placement_policy im... | [
"colossalai.utils.cuda.get_current_device"
] | [((1372, 1423), 'functools.partial', 'functools.partial', (['self._trans_state', 't.trans_state'], {}), '(self._trans_state, t.trans_state)\n', (1389, 1423), False, 'import functools\n'), ((3362, 3382), 'colossalai.utils.cuda.get_current_device', 'get_current_device', ([], {}), '()\n', (3380, 3382), False, 'from coloss... |
from tests.components_to_test.registry import non_distributed_component_funcs
import colossalai
import pytest
import torch.multiprocessing as mp
from colossalai.testing import parameterize, rerun_if_address_is_in_use
from colossalai.utils.cuda import get_current_device
from colossalai.utils import free_port
from colos... | [
"colossalai.launch",
"colossalai.utils.free_port",
"colossalai.utils.cuda.get_current_device",
"colossalai.testing.rerun_if_address_is_in_use",
"colossalai.testing.parameterize"
] | [((1523, 1557), 'colossalai.testing.parameterize', 'parameterize', (['"""world_size"""', '[1, 4]'], {}), "('world_size', [1, 4])\n", (1535, 1557), False, 'from colossalai.testing import parameterize, rerun_if_address_is_in_use\n'), ((1559, 1587), 'colossalai.testing.rerun_if_address_is_in_use', 'rerun_if_address_is_in_... |
import torch
from .simple_model import MLP
from colossalai.utils import Timer, synchronize
from colossalai.core import global_context as gpc
from colossalai.context.parallel_mode import ParallelMode
from argparse import ArgumentParser
BATCH_SIZE = 8
SEQ_LENGTH = 120
HIDDEN_DIM = 1024
ITER_TIMES = 2000
def build_args_... | [
"colossalai.core.global_context.init_parallel_groups",
"colossalai.core.global_context.get_local_rank",
"colossalai.core.global_context.load_config",
"colossalai.utils.Timer",
"colossalai.utils.synchronize",
"colossalai.core.global_context.is_initialized"
] | [((422, 470), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""colossal benchmark"""'}), "(description='colossal benchmark')\n", (436, 470), False, 'from argparse import ArgumentParser\n'), ((1427, 1474), 'torch.rand', 'torch.rand', (['args.bs', 'args.seq_len', 'args.hid_dim'], {}), '(args.bs, args... |
from functools import partial
import pytest
import torch.nn as nn
import torch.multiprocessing as mp
import torch.distributed as dist
import colossalai
from colossalai.utils import free_port, get_current_device
from colossalai.nn.layer.moe import Experts
from colossalai.context.moe_context import MOE_CONTEXT
from colos... | [
"colossalai.launch",
"colossalai.utils.moe.sync_moe_model_param",
"colossalai.utils.free_port",
"colossalai.utils.get_current_device",
"colossalai.testing.rerun_if_address_is_in_use",
"colossalai.context.moe_context.MOE_CONTEXT.setup",
"colossalai.testing.assert_equal_in_group",
"colossalai.nn.layer.m... | [((2380, 2408), 'colossalai.testing.rerun_if_address_is_in_use', 'rerun_if_address_is_in_use', ([], {}), '()\n', (2406, 2408), False, 'from colossalai.testing import assert_equal_in_group, rerun_if_address_is_in_use\n'), ((534, 650), 'colossalai.launch', 'colossalai.launch', ([], {'config': 'CONFIG', 'rank': 'rank', 'w... |
from copy import copy
from colossalai.utils.cuda import get_current_device
from colossalai.utils.model.colo_init_context import ColoInitContext
import torch
from colossalai.context.parallel_mode import ParallelMode
from colossalai.tensor import ColoTensor, distspec
from functools import partial
import colossalai
impo... | [
"colossalai.launch",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_local_rank",
"colossalai.core.global_context.get_world_size",
"colossalai.tensor.ParallelAction",
"colossalai.utils.free_port",
"colossalai.utils.cuda.get_current_device",
"colossalai.tensor.init_colo_... | [((7574, 7619), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[1, 4]'], {}), "('world_size', [1, 4])\n", (7597, 7619), False, 'import pytest\n'), ((7621, 7649), 'colossalai.testing.rerun_if_address_is_in_use', 'rerun_if_address_is_in_use', ([], {}), '()\n', (7647, 7649), False, 'from colo... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
# adpated from torch.utils.data.DistributedSampler
import math
import random
import numpy as np
from typing import TypeVar, Iterator
import torch
from torch.utils.data import Sampler, Dataset, DataLoader
from colossalai.context.parallel_mode import ParallelMode
from co... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.is_initialized"
] | [((417, 448), 'typing.TypeVar', 'TypeVar', (['"""T_co"""'], {'covariant': '(True)'}), "('T_co', covariant=True)\n", (424, 448), False, 'from typing import TypeVar, Iterator\n'), ((1359, 1396), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.DATA'], {}), '(ParallelMode.DATA)\n', (1... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from copy import deepcopy
from functools import partial
import colossalai
import pytest
import torch
import torch.multiprocessing as mp
from colossalai.logging import disable_existing_loggers, get_dist_logger
from colossalai.testing import parameterize
from colossalai.u... | [
"colossalai.zero.sharded_param.ShardedParam",
"colossalai.launch",
"colossalai.logging.get_dist_logger",
"colossalai.utils.free_port",
"colossalai.logging.disable_existing_loggers",
"colossalai.testing.parameterize",
"colossalai.zero.sharded_param.sharded_param.ShardedParamV2"
] | [((719, 809), 'colossalai.testing.parameterize', 'parameterize', (['"""shard_strategy_class"""', '[TensorShardStrategy, BucketTensorShardStrategy]'], {}), "('shard_strategy_class', [TensorShardStrategy,\n BucketTensorShardStrategy])\n", (731, 809), False, 'from colossalai.testing import parameterize\n'), ((1567, 161... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import torch
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import get_current_device, synchronize
def ring_forward(tensor_send_next: torch.Tensor, parallel_mode: ParallelMode):
"""... | [
"colossalai.core.global_context.get_prev_global_rank",
"colossalai.utils.get_current_device",
"colossalai.utils.synchronize",
"colossalai.core.global_context.get_global_rank",
"colossalai.core.global_context.get_next_global_rank"
] | [((1022, 1043), 'colossalai.core.global_context.get_global_rank', 'gpc.get_global_rank', ([], {}), '()\n', (1041, 1043), True, 'from colossalai.core import global_context as gpc\n'), ((1746, 1786), 'torch.distributed.batch_isend_irecv', 'torch.distributed.batch_isend_irecv', (['ops'], {}), '(ops)\n', (1781, 1786), Fals... |
import pytest
from colossalai.utils.model.colo_init_context import ColoInitContext
import torch
from colossalai.utils.cuda import get_current_device
@pytest.mark.skip
# FIXME(ver217): support lazy init
def test_lazy_init():
in_dim = 4
out_dim = 5
with ColoInitContext(lazy_memory_allocate=True) as ctx:
... | [
"colossalai.utils.model.colo_init_context.ColoInitContext",
"colossalai.utils.cuda.get_current_device"
] | [((269, 311), 'colossalai.utils.model.colo_init_context.ColoInitContext', 'ColoInitContext', ([], {'lazy_memory_allocate': '(True)'}), '(lazy_memory_allocate=True)\n', (284, 311), False, 'from colossalai.utils.model.colo_init_context import ColoInitContext\n'), ((333, 376), 'torch.nn.Linear', 'torch.nn.Linear', (['in_d... |
import torch
from colossalai.context.parallel_mode import ParallelMode
from colossalai.tensor import ColoTensor
from functools import partial
import colossalai
import pytest
import torch
import torch.multiprocessing as mp
from colossalai.testing import rerun_if_address_is_in_use
from colossalai.utils.cuda import get_... | [
"colossalai.tensor.ParallelAction",
"colossalai.core.global_context.get_local_rank",
"colossalai.launch",
"colossalai.utils.free_port",
"colossalai.utils.cuda.get_current_device",
"colossalai.core.global_context.get_world_size",
"colossalai.tensor.TensorSpec",
"colossalai.tensor.ColoTensor.init_from_t... | [((5300, 5345), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[1, 4]'], {}), "('world_size', [1, 4])\n", (5323, 5345), False, 'import pytest\n'), ((5347, 5375), 'colossalai.testing.rerun_if_address_is_in_use', 'rerun_if_address_is_in_use', ([], {}), '()\n', (5373, 5375), False, 'from colo... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from colossalai.context import ParallelContext, MoeContext
global_context = ParallelContext.get_instance()
MOE_CONTEXT = MoeContext.get_instance()
| [
"colossalai.context.MoeContext.get_instance",
"colossalai.context.ParallelContext.get_instance"
] | [((126, 156), 'colossalai.context.ParallelContext.get_instance', 'ParallelContext.get_instance', ([], {}), '()\n', (154, 156), False, 'from colossalai.context import ParallelContext, MoeContext\n'), ((171, 196), 'colossalai.context.MoeContext.get_instance', 'MoeContext.get_instance', ([], {}), '()\n', (194, 196), False... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import os
import os.path as osp
import torch
from tensorboardX import SummaryWriter
from colossalai.context import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.registry import HOOKS
from colossalai.trainer._trainer import Trainer
from ... | [
"colossalai.utils.is_no_pp_or_last_stage",
"colossalai.utils.report_memory_usage",
"colossalai.utils.get_global_multitimer",
"colossalai.utils.is_tp_rank_0",
"colossalai.utils.is_dp_rank_0",
"colossalai.core.global_context.get_global_rank",
"colossalai.core.global_context.is_initialized",
"colossalai.... | [((607, 635), 'torch.is_floating_point', 'torch.is_floating_point', (['val'], {}), '(val)\n', (630, 635), False, 'import torch\n'), ((3134, 3158), 'colossalai.utils.is_no_pp_or_last_stage', 'is_no_pp_or_last_stage', ([], {}), '()\n', (3156, 3158), False, 'from colossalai.utils import get_global_multitimer, set_global_m... |
import os
from pathlib import Path
import colossalai
import torch
from colossalai.core import global_context as gpc
from colossalai.logging import get_dist_logger
from colossalai.nn.lr_scheduler import LinearWarmupLR
from colossalai.trainer import Trainer, hooks
from colossalai.utils import get_dataloader
from timm.mo... | [
"colossalai.logging.get_dist_logger",
"colossalai.initialize",
"colossalai.utils.get_dataloader",
"colossalai.launch_from_torch",
"colossalai.nn.lr_scheduler.LinearWarmupLR",
"colossalai.get_default_parser"
] | [((774, 805), 'colossalai.get_default_parser', 'colossalai.get_default_parser', ([], {}), '()\n', (803, 805), False, 'import colossalai\n'), ((866, 914), 'colossalai.launch_from_torch', 'colossalai.launch_from_torch', ([], {'config': 'args.config'}), '(config=args.config)\n', (894, 914), False, 'import colossalai\n'), ... |
import math
from typing import Callable
import torch
from colossalai import nn as col_nn
from colossalai.builder.pipeline import partition_uniform
from colossalai.context import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.logging import get_dist_logger
from colossalai.nn.lay... | [
"colossalai.utils.get_current_device",
"colossalai.nn.Linear",
"colossalai.core.global_context.get_local_rank",
"colossalai.logging.get_dist_logger",
"colossalai.nn.Classifier",
"colossalai.core.global_context.get_world_size",
"colossalai.nn.LayerNorm",
"colossalai.builder.pipeline.partition_uniform",... | [((15943, 15960), 'colossalai.logging.get_dist_logger', 'get_dist_logger', ([], {}), '()\n', (15958, 15960), False, 'from colossalai.logging import get_dist_logger\n'), ((15982, 16023), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.PIPELINE'], {}), '(ParallelMode.PIPELINE)\n', (... |
from colossalai.context.parallel_mode import ParallelMode
import torch
from colossalai.engine.ophooks import BaseOpHook
from colossalai.registry import OPHOOKS
from colossalai.logging import get_dist_logger
from colossalai.core import global_context as gpc
from colossalai.utils.memory_tracer import AsyncMemoryMonitor
... | [
"colossalai.logging.get_dist_logger",
"colossalai.utils.memory_tracer.AsyncMemoryMonitor",
"colossalai.core.global_context.get_global_rank",
"colossalai.core.global_context.is_initialized"
] | [((970, 990), 'colossalai.utils.memory_tracer.AsyncMemoryMonitor', 'AsyncMemoryMonitor', ([], {}), '()\n', (988, 990), False, 'from colossalai.utils.memory_tracer import AsyncMemoryMonitor\n'), ((1040, 1057), 'colossalai.logging.get_dist_logger', 'get_dist_logger', ([], {}), '()\n', (1055, 1057), False, 'from colossala... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from functools import partial
import colossalai
import pytest
import torch
import torch.distributed as dist
import torch.multiprocessing as mp
from colossalai.core import global_context as gpc
from colossalai.testing import rerun_on_exception
from colossalai.utils impor... | [
"colossalai.zero.sharded_optim._utils.has_inf_or_nan",
"colossalai.launch",
"colossalai.initialize",
"colossalai.utils.free_port",
"colossalai.testing.rerun_on_exception",
"colossalai.zero.sharded_model.utils.col_model_deepcopy"
] | [((3576, 3621), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[2, 4]'], {}), "('world_size', [2, 4])\n", (3599, 3621), False, 'import pytest\n'), ((3623, 3726), 'colossalai.testing.rerun_on_exception', 'rerun_on_exception', ([], {'exception_type': 'mp.ProcessRaisedException', 'pattern': '... |
import torch
import colossalai
import pytest
import torch.multiprocessing as mp
from colossalai.utils.cuda import get_current_device
from colossalai.gemini.memory_tracer import MemStatsCollector
from colossalai.gemini.memory_tracer import GLOBAL_MODEL_DATA_TRACER
from colossalai.utils.memory import colo_set_process_mem... | [
"colossalai.gemini.tensor_placement_policy.AutoTensorPlacementPolicy",
"colossalai.gemini.memory_tracer.GLOBAL_MODEL_DATA_TRACER.register_model",
"colossalai.launch",
"colossalai.gemini.StatefulTensorMgr",
"colossalai.utils.free_port",
"colossalai.utils.cuda.get_current_device",
"colossalai.gemini.memor... | [((4772, 4800), 'colossalai.testing.rerun_if_address_is_in_use', 'rerun_if_address_is_in_use', ([], {}), '()\n', (4798, 4800), False, 'from colossalai.testing import rerun_if_address_is_in_use\n'), ((1271, 1313), 'colossalai.utils.memory.colo_set_process_memory_fraction', 'colo_set_process_memory_fraction', (['fraction... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import torch
import torch.nn as nn
import torch.distributed as dist
from torch import Tensor
from typing import Any
from torch.optim import Optimizer
from torch.distributed import ReduceOp
from colossalai.core import global_context as gpc
from colossalai.context import P... | [
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.is_initialized"
] | [((1898, 1931), 'colossalai.core.global_context.is_initialized', 'gpc.is_initialized', (['parallel_mode'], {}), '(parallel_mode)\n', (1916, 1931), True, 'from colossalai.core import global_context as gpc\n'), ((2009, 2037), 'colossalai.core.global_context.get_group', 'gpc.get_group', (['parallel_mode'], {}), '(parallel... |
from .base_benchmarker import Benchmaker
from colossalai.context import Config
import torch
from colossalai.zero import ShardedModel, ShardedOptimizer
class ColossalaiBenchmarker(Benchmaker):
def __init__(self, config_path, optim_class, model, criterion):
config = Config.from_file(config_path)
op... | [
"colossalai.zero.ShardedOptimizer",
"colossalai.zero.ShardedModel",
"colossalai.context.Config.from_file"
] | [((280, 309), 'colossalai.context.Config.from_file', 'Config.from_file', (['config_path'], {}), '(config_path)\n', (296, 309), False, 'from colossalai.context import Config\n'), ((481, 543), 'colossalai.zero.ShardedOptimizer', 'ShardedOptimizer', ([], {'optimizer': 'optimizer'}), '(optimizer=optimizer, **config.zero.op... |
import torch
import torch.nn as nn
from torch.optim.adam import Adam
from torch.optim import AdamW
from colossalai.nn.optimizer.hybrid_adam import HybridAdam
from colossalai.testing import parameterize
RE = 1024
@parameterize('adamw', [False, True])
@parameterize('device', ['cpu', 'cuda:0'])
@parameterize('p_dtype'... | [
"colossalai.nn.optimizer.hybrid_adam.HybridAdam",
"colossalai.testing.parameterize"
] | [((217, 253), 'colossalai.testing.parameterize', 'parameterize', (['"""adamw"""', '[False, True]'], {}), "('adamw', [False, True])\n", (229, 253), False, 'from colossalai.testing import parameterize\n'), ((255, 296), 'colossalai.testing.parameterize', 'parameterize', (['"""device"""', "['cpu', 'cuda:0']"], {}), "('devi... |
import math
import time
import torch
from colossalai.utils import MultiTimer
from colossalai.context import ParallelMode, Config
from typing import List, Dict, Tuple, Callable
def get_time_stamp() -> int:
"""
Return the time stamp for profiling.
Returns:
time_stamp (int): the time given by time.... | [
"colossalai.context.Config"
] | [((340, 364), 'torch.cuda.synchronize', 'torch.cuda.synchronize', ([], {}), '()\n', (362, 364), False, 'import torch\n'), ((382, 393), 'time.time', 'time.time', ([], {}), '()\n', (391, 393), False, 'import time\n'), ((767, 803), 'torch.cuda.reset_peak_memory_stats', 'torch.cuda.reset_peak_memory_stats', ([], {}), '()\n... |
import math
from typing import Callable
import torch
import torch.nn as nn
import torch.nn.functional as F
from colossalai.communication import broadcast
from colossalai.context import ParallelMode, seed
from colossalai.core import global_context as gpc
from colossalai.global_variables import tensor_parallel_env as en... | [
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_ranks_in_group",
"colossalai.nn.init.zeros_",
"colossalai.core.global_context.get_local_rank",
"colossalai.context.seed",
"colossalai.utils.cuda.get_current_device",
"colossalai.nn.init.xavier_uniform_",
"colossalai.commun... | [((2068, 2102), 'colossalai.nn.init.xavier_uniform_', 'init.xavier_uniform_', ([], {'a': '(1)', 'scale': '(1)'}), '(a=1, scale=1)\n', (2088, 2102), True, 'from colossalai.nn import init as init\n'), ((2350, 2400), 'colossalai.core.global_context.get_local_rank', 'gpc.get_local_rank', (['ParallelMode.PARALLEL_2P5D_COL']... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from typing import List, Tuple, Union
import torch
import torch.distributed as dist
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import get_current_device
from functools import reduce
i... | [
"colossalai.core.global_context.get_prev_global_rank",
"colossalai.core.global_context.is_pipeline_last_stage",
"colossalai.core.global_context.is_pipeline_first_stage",
"colossalai.utils.get_current_device",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.get_next_global_... | [((7203, 7227), 'torch.cuda.synchronize', 'torch.cuda.synchronize', ([], {}), '()\n', (7225, 7227), False, 'import torch\n'), ((8731, 8760), 'colossalai.core.global_context.is_pipeline_first_stage', 'gpc.is_pipeline_first_stage', ([], {}), '()\n', (8758, 8760), True, 'from colossalai.core import global_context as gpc\n... |
import torch.nn as nn
from colossalai.context import ParallelMode, seed
from ..parallel_1d import *
from ..utils import get_tensor_parallel_mode
from ._utils import ColossalaiModule
class Dropout(ColossalaiModule):
"""Dropout layer of colossalai.
Args:
p (float, optional): probability of... | [
"colossalai.context.seed"
] | [((697, 719), 'torch.nn.Dropout', 'nn.Dropout', (['p', 'inplace'], {}), '(p, inplace)\n', (707, 719), True, 'import torch.nn as nn\n'), ((947, 972), 'colossalai.context.seed', 'seed', (['ParallelMode.TENSOR'], {}), '(ParallelMode.TENSOR)\n', (951, 972), False, 'from colossalai.context import ParallelMode, seed\n')] |
from typing import Tuple, Optional
import torch
import torch.nn as nn
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from fastfold.model.fastnn import MSAStack, OutProductMean, PairStack
from fastfold.distributed.comm_async import All_to_All_Async, All_to_... | [
"colossalai.core.global_context.get_world_size"
] | [((655, 686), 'fastfold.model.fastnn.MSAStack', 'MSAStack', (['c_m', 'c_z'], {'p_drop': '(0.15)'}), '(c_m, c_z, p_drop=0.15)\n', (663, 686), False, 'from fastfold.model.fastnn import MSAStack, OutProductMean, PairStack\n'), ((716, 774), 'fastfold.model.fastnn.OutProductMean', 'OutProductMean', ([], {'n_feat': 'c_m', 'n... |
from functools import partial
import pytest
import torch
import torch.nn as nn
import torch.multiprocessing as mp
import colossalai
from colossalai.context import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import free_port, get_current_device
from colossalai.nn.layer.m... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.launch",
"colossalai.global_variables.moe_env.reset_loss",
"colossalai.utils.free_port",
"colossalai.nn.layer.moe.Top2Router",
"colossalai.utils.get_current_device"
] | [((2658, 2723), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""Should be activated for detailed tests"""'}), "(reason='Should be activated for detailed tests')\n", (2674, 2723), False, 'import pytest\n'), ((2726, 2768), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""rs"""', '[2, 42, 60]'], {})... |
from colossalai.context.parallel_mode import ParallelMode
from colossalai.logging import get_dist_logger, disable_existing_loggers
import colossalai
import os
from colossalai.core import global_context as gpc
from colossalai.utils.timer import MultiTimer
from colossalai.zero.init_ctx import ZeroInitContext
impor... | [
"colossalai.nn.LinearWarmupLR",
"colossalai.trainer.hooks.ThroughputHook",
"colossalai.trainer.Trainer",
"colossalai.trainer.hooks.LogMetricByStepHook",
"colossalai.core.global_context.get_local_rank",
"colossalai.trainer.hooks.LossHook",
"colossalai.logging.get_dist_logger",
"colossalai.initialize",
... | [((740, 771), 'colossalai.get_default_parser', 'colossalai.get_default_parser', ([], {}), '()\n', (769, 771), False, 'import colossalai\n'), ((886, 912), 'colossalai.logging.disable_existing_loggers', 'disable_existing_loggers', ([], {}), '()\n', (910, 912), False, 'from colossalai.logging import get_dist_logger, disab... |
import math
import os
from typing import Tuple, Optional
import torch
import torch.distributed as dist
from colossalai.constants import (INPUT_GROUP_3D, OUTPUT_GROUP_3D,
WEIGHT_GROUP_3D)
from colossalai.context import ParallelMode, seed
from colossalai.core import global_context as gp... | [
"colossalai.utils.checkpoint",
"colossalai.core.global_context.get_local_rank",
"colossalai.utils.get_current_device",
"colossalai.nn.init.init_weight_",
"colossalai.nn.init.init_bias_",
"colossalai.context.seed",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_ranks_in... | [((2634, 2737), 'torch.nn.Conv2d', 'nn.Conv2d', (['self.in_chans', 'self.embed_size_per_partition'], {'kernel_size': 'patch_size', 'stride': 'patch_size'}), '(self.in_chans, self.embed_size_per_partition, kernel_size=\n patch_size, stride=patch_size)\n', (2643, 2737), False, 'from torch import Tensor, dtype, nn\n'),... |
from pathlib import Path
from colossalai.logging import get_dist_logger
import colossalai
import torch
import os
from colossalai.core import global_context as gpc
from colossalai.utils import get_dataloader, MultiTimer
from colossalai.trainer import Trainer, hooks
from colossalai.nn.metric import Accuracy
from torchvis... | [
"colossalai.trainer.Trainer",
"colossalai.trainer.hooks.LogTimingByEpochHook",
"colossalai.trainer.hooks.LossHook",
"colossalai.logging.get_dist_logger",
"colossalai.initialize",
"colossalai.launch_from_torch",
"colossalai.trainer.hooks.LogMemoryByEpochHook",
"colossalai.utils.MultiTimer",
"colossal... | [((549, 581), 'os.environ.get', 'os.environ.get', (['"""DATA"""', '"""./data"""'], {}), "('DATA', './data')\n", (563, 581), False, 'import os\n'), ((610, 641), 'colossalai.get_default_parser', 'colossalai.get_default_parser', ([], {}), '()\n', (639, 641), False, 'import colossalai\n'), ((771, 821), 'colossalai.launch_f... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import pprint
from functools import partial
import colossalai.nn as col_nn
import pytest
import torch
import torch.multiprocessing as mp
import torch.nn as nn
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_contex... | [
"colossalai.testing.rerun_on_exception",
"colossalai.nn.Linear",
"colossalai.core.global_context.get_local_rank",
"colossalai.core.global_context.get_world_size",
"colossalai.logging.disable_existing_loggers",
"colossalai.utils.checkpointing.load_checkpoint",
"colossalai.builder.pipeline.partition_unifo... | [((2359, 2462), 'colossalai.testing.rerun_on_exception', 'rerun_on_exception', ([], {'exception_type': 'mp.ProcessRaisedException', 'pattern': '""".*Address already in use.*"""'}), "(exception_type=mp.ProcessRaisedException, pattern=\n '.*Address already in use.*')\n", (2377, 2462), False, 'from colossalai.testing i... |
import os
import os.path as osp
import re
from typing import Tuple
from pathlib import Path
import torch
from colossalai.context import Config
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
__all__ = [
'get_checkpoint_path', 'get_latest_checkpoint_path... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.core.global_context.is_initialized"
] | [((769, 808), 'colossalai.core.global_context.is_initialized', 'gpc.is_initialized', (['ParallelMode.TENSOR'], {}), '(ParallelMode.TENSOR)\n', (787, 808), True, 'from colossalai.core import global_context as gpc\n'), ((928, 969), 'colossalai.core.global_context.is_initialized', 'gpc.is_initialized', (['ParallelMode.PIP... |
from typing import Tuple
import torch
import torch.distributed as dist
from torch import Tensor
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from .core import ensure_divisibility
def divide(numerator, denominator):
ensure_divisibility(numerator, de... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_world_size"
] | [((904, 944), 'torch.split', 'torch.split', (['tensor', 'split_size'], {'dim': 'dim'}), '(tensor, split_size, dim=dim)\n', (915, 944), False, 'import torch\n'), ((4381, 4424), 'torch.split', 'torch.split', (['tensor', 'split_size'], {'dim': 'in_dim'}), '(tensor, split_size, dim=in_dim)\n', (4392, 4424), False, 'import ... |
from colossalai.context.parallel_context import ParallelContext
from colossalai.core import global_context as gpc
from colossalai.logging import get_dist_logger
from colossalai.context import ParallelMode
from .datasets.data_samplers import build_pretraining_data_loader
from .datasets.builder import build_train_valid_t... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.logging.get_dist_logger",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.is_initialized",
"colossalai.core.global_context.get_ranks_in_group"
] | [((916, 933), 'colossalai.logging.get_dist_logger', 'get_dist_logger', ([], {}), '()\n', (931, 933), False, 'from colossalai.logging import get_dist_logger\n'), ((2658, 2695), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.DATA'], {}), '(ParallelMode.DATA)\n', (2676, 2695), True,... |
import pytest
import colossalai
from colossalai.utils.cuda import get_current_device
from colossalai.zero.sharded_param import (StatefulTensor, colo_tensor_mem_usage, colo_model_data_tensor_move,
colo_model_data_tensor_move_inline, colo_model_data_move_to_cpu,
... | [
"colossalai.launch",
"colossalai.zero.sharded_param.colo_model_data_tensor_move",
"colossalai.zero.sharded_param.colo_tensor_mem_usage",
"colossalai.utils.free_port",
"colossalai.utils.cuda.get_current_device",
"colossalai.zero.sharded_param.colo_model_data_move_to_cpu",
"colossalai.testing.rerun_if_add... | [((3116, 3161), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[4, 5]'], {}), "('world_size', [4, 5])\n", (3139, 3161), False, 'import pytest\n'), ((3163, 3191), 'colossalai.testing.rerun_if_address_is_in_use', 'rerun_if_address_is_in_use', ([], {}), '()\n', (3189, 3191), False, 'from colo... |
# referenced from Megatron and used to testify communication
import os.path as osp
import pytest
import torch
from torch.utils.data import DataLoader
from colossalai.builder import ModelInitializer, build_dataset, build_optimizer, build_loss
from colossalai.communication import p2p as p2p_communication
from colossala... | [
"colossalai.communication.utils.recv_tensor_meta",
"colossalai.core.global_context.is_last_rank",
"colossalai.utils.get_current_device",
"colossalai.core.global_context.get_local_rank",
"colossalai.communication.p2p.send_backward",
"colossalai.core.global_context.get_world_size",
"colossalai.communicati... | [((6926, 6982), 'os.path.join', 'osp.join', (['DIR_PATH', '"""../configs/pipeline_vanilla_vit.py"""'], {}), "(DIR_PATH, '../configs/pipeline_vanilla_vit.py')\n", (6934, 6982), True, 'import os.path as osp\n'), ((6986, 7077), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""This is only for debugging purpose,... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import math
from colossalai import context
import torch
from torch import nn as nn, Tensor, distributed as dist
from torch.nn.init import _calculate_fan_in_and_fan_out
from colossalai.context import seed, ParallelMode
from colossalai.core import global_context as gpc
f... | [
"colossalai.utils.get_current_device",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_ranks_in_group",
"colossalai.nn.layer._common_utils.divide",
"colossalai.utils.checkpoint",
"colossalai.context.seed"
] | [((2805, 2829), 'torch.nn.Dropout', 'nn.Dropout', (['dropout_prob'], {}), '(dropout_prob)\n', (2815, 2829), True, 'from torch import nn as nn, Tensor, distributed as dist\n'), ((3509, 3549), 'colossalai.utils.checkpoint', 'checkpoint', (['self._forward', 'hidden_states'], {}), '(self._forward, hidden_states)\n', (3519,... |
from colossalai.context.parallel_mode import ParallelMode
import torch
import torch.nn as nn
import inspect
from .layers import Embedding, BertLayer, BertDualHead, PreProcessor, VocabEmbedding
from .layers.init_method import init_normal, output_init_normal
from colossalai.core import global_context as gpc
from colossal... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.logging.get_dist_logger",
"colossalai.nn.layer.wrapper.PipelineSharedModuleWrapper",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.get_global_rank",
"colossalai.kernel.LayerNorm",
"colossalai.builder.pipeline... | [((10836, 10859), 'inspect.signature', 'inspect.signature', (['func'], {}), '(func)\n', (10853, 10859), False, 'import inspect\n'), ((10985, 11005), 'torch.device', 'torch.device', (['"""cuda"""'], {}), "('cuda')\n", (10997, 11005), False, 'import torch\n'), ((11031, 11048), 'colossalai.logging.get_dist_logger', 'get_d... |
import torch
from typing import Union
from colossalai.tensor.op_wrapper import colo_op_impl
from colossalai.nn.layer.parallel_1d._utils import split_forward_gather_backward, reduce_input, reduce_grad
from colossalai.nn.layer.utils import divide
from colossalai.core import global_context as gpc
from colossalai.tensor im... | [
"colossalai.tensor.ColoTensor.init_from_torch_tensor",
"colossalai.tensor.op_wrapper.colo_op_impl",
"colossalai.tensor.ParallelAction",
"colossalai.nn.layer.parallel_1d._utils.reduce_input"
] | [((2694, 2719), 'colossalai.tensor.op_wrapper.colo_op_impl', 'colo_op_impl', (['torch.addmm'], {}), '(torch.addmm)\n', (2706, 2719), False, 'from colossalai.tensor.op_wrapper import colo_op_impl\n'), ((1090, 1149), 'colossalai.nn.layer.parallel_1d._utils.reduce_input', 'reduce_input', (['partial_output', 'parallel_acti... |
from typing import Any, Optional, Tuple
import torch
import torch.distributed as dist
from colossalai.communication.collective import (all_gather, all_reduce, reduce, reduce_scatter)
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.communication.collective.reduce_scatter",
"colossalai.communication.collective.all_gather",
"colossalai.core.global_context.get_group",
"colossalai.communication.collective.all_reduce",
"colossalai.core.global_context.get_world_size",
"colossa... | [((2634, 2671), 'torch.cuda.amp.custom_fwd', 'custom_fwd', ([], {'cast_inputs': 'torch.float16'}), '(cast_inputs=torch.float16)\n', (2644, 2671), False, 'from torch.cuda.amp import custom_bwd, custom_fwd\n'), ((7989, 8026), 'torch.cuda.amp.custom_fwd', 'custom_fwd', ([], {'cast_inputs': 'torch.float16'}), '(cast_inputs... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.nn.layer.parallel_1d._utils import vocab_range_from_per_parti... | [
"colossalai.core.global_context.get_local_rank",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_world_size",
"colossalai.nn.layer.parallel_1d._utils.vocab_range_from_per_partition_vocab_size"
] | [((1033, 1077), 'colossalai.core.global_context.get_local_rank', 'gpc.get_local_rank', (['ParallelMode.PARALLEL_1D'], {}), '(ParallelMode.PARALLEL_1D)\n', (1051, 1077), True, 'from colossalai.core import global_context as gpc\n'), ((1099, 1143), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['... |
import torch
import colossalai
import colossalai.nn as col_nn
class MLP(torch.nn.Module):
def __init__(self, dim: int = 256):
super().__init__()
intermediate_dim = dim * 4
self.dense_1 = col_nn.Linear(dim, intermediate_dim)
self.activation = torch.nn.GELU()
self.dense_2 = co... | [
"colossalai.nn.Linear",
"colossalai.nn.Dropout"
] | [((216, 252), 'colossalai.nn.Linear', 'col_nn.Linear', (['dim', 'intermediate_dim'], {}), '(dim, intermediate_dim)\n', (229, 252), True, 'import colossalai.nn as col_nn\n'), ((279, 294), 'torch.nn.GELU', 'torch.nn.GELU', ([], {}), '()\n', (292, 294), False, 'import torch\n'), ((318, 354), 'colossalai.nn.Linear', 'col_n... |
#!/usr/bin/env python
import torch.distributed as dist
from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
from colossalai.core import global_context as gpc
from colossalai.registry import GRADIENT_HANDLER
from ._base_gradient_handler import BaseGradientHandler
from ...context.parallel_mode impo... | [
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.get_group"
] | [((1642, 1671), 'torch._utils._flatten_dense_tensors', '_flatten_dense_tensors', (['grads'], {}), '(grads)\n', (1664, 1671), False, 'from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors\n'), ((1701, 1738), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.DATA']... |
import sys
import os
import torch
import argparse
from DataSets import create_datasets, create_dataloader
from Utils.eval import eval_model
from Utils.tools import analysis_dataset
from Utils.ddp_tools import init_env, save_model, copy_model, DDP_SummaryWriter
from Models.Backbone import create_backbone
from Models.Los... | [
"colossalai.initialize",
"colossalai.get_default_parser"
] | [((515, 540), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (530, 540), False, 'import os\n'), ((598, 629), 'colossalai.get_default_parser', 'colossalai.get_default_parser', ([], {}), '()\n', (627, 629), False, 'import colossalai\n'), ((834, 859), 'Utils.tools.analysis_dataset', 'analysis_da... |
import pytest
import colossalai
from colossalai.context.parallel_mode import ParallelMode
import torch.multiprocessing as mp
from colossalai.testing import rerun_if_address_is_in_use
from colossalai.utils.cuda import get_current_device
from colossalai.utils import free_port
from colossalai.utils import ColoInitContext
... | [
"colossalai.tensor.ParallelAction",
"colossalai.nn.parallel.ColoDDP",
"colossalai.launch",
"colossalai.core.global_context.get_local_rank",
"colossalai.utils.free_port",
"colossalai.utils.cuda.get_current_device",
"colossalai.core.global_context.get_group",
"colossalai.core.global_context.get_world_si... | [((3704, 3749), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[1, 4]'], {}), "('world_size', [1, 4])\n", (3727, 3749), False, 'import pytest\n'), ((3751, 3800), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""use_ddp"""', '[False, True]'], {}), "('use_ddp', [False, True])\n", ... |
from functools import partial
import torch
import torch.distributed as dist
import torch.nn as nn
from colossalai.logging import get_dist_logger
from colossalai.utils import checkpoint
from colossalai.zero.sharded_model import ShardedModelV2
LOGGER = get_dist_logger()
CONFIG = dict(fp16=dict(mode=None,),
... | [
"colossalai.logging.get_dist_logger"
] | [((254, 271), 'colossalai.logging.get_dist_logger', 'get_dist_logger', ([], {}), '()\n', (269, 271), False, 'from colossalai.logging import get_dist_logger\n'), ((1664, 1698), 'torch.allclose', 'torch.allclose', (['tensor_a', 'tensor_b'], {}), '(tensor_a, tensor_b)\n', (1678, 1698), False, 'import torch\n'), ((2328, 23... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from .amp_type import AMP_TYPE
from colossalai.context import Config
import torch.nn as nn
from torch.optim import Optimizer
from torch.nn.modules.loss import _Loss
from .torch_amp import convert_to_torch_amp
from .apex_amp import convert_to_apex_amp
from .naive_amp impo... | [
"colossalai.context.Config"
] | [((1257, 1265), 'colossalai.context.Config', 'Config', ([], {}), '()\n', (1263, 1265), False, 'from colossalai.context import Config\n')] |
from typing import Optional
from colossalai.utils import get_current_device
from torch import nn
from ... import init as init
from ..parallel_1d import *
from ..parallel_2d import *
from ..parallel_2p5d import *
from ..parallel_3d import *
from ..utils import get_tensor_parallel_mode
from ..vanilla import ... | [
"colossalai.utils.get_current_device"
] | [((1438, 1458), 'colossalai.utils.get_current_device', 'get_current_device', ([], {}), '()\n', (1456, 1458), False, 'from colossalai.utils import get_current_device\n')] |
from colossalai.utils.memory_tracer.memstats_collector import MemStatsCollector
from colossalai.utils.memory_tracer.model_data_memtracer import ModelDataTracer
import torch
def test_mem_collector():
collector = MemStatsCollector()
collector.start_collection()
a = torch.randn(10).cuda()
# sampling a... | [
"colossalai.utils.memory_tracer.model_data_memtracer.ModelDataTracer",
"colossalai.utils.memory_tracer.memstats_collector.MemStatsCollector"
] | [((217, 236), 'colossalai.utils.memory_tracer.memstats_collector.MemStatsCollector', 'MemStatsCollector', ([], {}), '()\n', (234, 236), False, 'from colossalai.utils.memory_tracer.memstats_collector import MemStatsCollector\n'), ((280, 295), 'torch.randn', 'torch.randn', (['(10)'], {}), '(10)\n', (291, 295), False, 'im... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from typing import Union, List
from colossalai import engine
from colossalai.context.parallel_mode import ParallelMode
import torch
from torch import Tensor
from torch.utils.data import DataLoader
from tqdm import tqdm
from colossalai.core import global_context as gpc
... | [
"colossalai.utils.is_no_pp_or_last_stage",
"colossalai.engine.schedule.NonPipelineSchedule",
"colossalai.utils.is_tp_rank_0",
"colossalai.utils.is_dp_rank_0",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.is_initialized"
] | [((2204, 2225), 'colossalai.engine.schedule.NonPipelineSchedule', 'NonPipelineSchedule', ([], {}), '()\n', (2223, 2225), False, 'from colossalai.engine.schedule import NonPipelineSchedule, BaseSchedule\n'), ((2237, 2278), 'colossalai.core.global_context.is_initialized', 'gpc.is_initialized', (['ParallelMode.PIPELINE'],... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import torch
import torch.distributed as dist
from torch.distributed import ReduceOp
from torch import Tensor
from colossalai.context import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.utils import get_current_device
def all_gather(t... | [
"colossalai.core.global_context.get_group",
"colossalai.utils.get_current_device",
"colossalai.core.global_context.get_world_size"
] | [((905, 938), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['parallel_mode'], {}), '(parallel_mode)\n', (923, 938), True, 'from colossalai.core import global_context as gpc\n'), ((2343, 2376), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['parallel_mode'], {}), '(pa... |
import torch
import torch.distributed as dist
from colossalai.initialize import parse_args
from colossalai.utils import get_current_device
ARGS = parse_args()
size = ARGS.world_size
rank = ARGS.local_rank
init_method = f'tcp://{ARGS.host}:{ARGS.port}'
dist.init_process_group(backend='nccl', rank=rank, world_size=siz... | [
"colossalai.initialize.parse_args",
"colossalai.utils.get_current_device"
] | [((148, 160), 'colossalai.initialize.parse_args', 'parse_args', ([], {}), '()\n', (158, 160), False, 'from colossalai.initialize import parse_args\n'), ((255, 351), 'torch.distributed.init_process_group', 'dist.init_process_group', ([], {'backend': '"""nccl"""', 'rank': 'rank', 'world_size': 'size', 'init_method': 'ini... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import copy
from functools import partial
import colossalai
import pytest
import torch
import torch.distributed as dist
import torch.multiprocessing as mp
from colossalai.nn.optimizer import CPUAdam
from colossalai.utils import free_port
from colossalai.zero.shard_utils... | [
"colossalai.launch",
"colossalai.utils.free_port",
"colossalai.zero.sharded_optim.ShardedOptimizerV2"
] | [((2957, 3002), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[1, 2]'], {}), "('world_size', [1, 2])\n", (2980, 3002), False, 'import pytest\n'), ((3004, 3099), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shard_strategy"""', '[TensorShardStrategy, BucketTensorShardStrategy... |
import pytest
import colossalai
from colossalai.context.parallel_mode import ParallelMode
import torch.multiprocessing as mp
from colossalai.testing import rerun_if_address_is_in_use
from colossalai.utils.cuda import get_current_device
from colossalai.utils import free_port
from colossalai.utils import ColoInitContext
... | [
"colossalai.testing.rerun_if_address_is_in_use",
"colossalai.testing.parameterize",
"colossalai.launch",
"colossalai.nn.parallel.ColoDDPV2",
"colossalai.utils.free_port",
"colossalai.utils.cuda.get_current_device",
"colossalai.tensor.ChunkManager",
"colossalai.core.global_context.get_global_rank",
"... | [((1267, 1307), 'colossalai.testing.parameterize', 'parameterize', (['"""use_chunk"""', '[False, True]'], {}), "('use_chunk', [False, True])\n", (1279, 1307), False, 'from colossalai.testing import parameterize\n'), ((1309, 1348), 'colossalai.testing.parameterize', 'parameterize', (['"""use_zero"""', '[False, True]'], ... |
import os
from abc import ABC, abstractmethod
import torch
import torch.distributed as dist
from colossalai.communication import all_gather
from colossalai.constants import (INPUT_GROUP_3D, OUTPUT_GROUP_3D,
WEIGHT_GROUP_3D)
from colossalai.context import ParallelMode
from col... | [
"colossalai.core.global_context.get_world_size",
"colossalai.communication.all_gather",
"colossalai.nn.layer._parallel_utilities._gather",
"colossalai.nn.layer.parallel_3d._utils.get_parallel_mode_from_env",
"colossalai.core.global_context.is_initialized",
"colossalai.utils.get_current_device",
"colossa... | [((3577, 3614), 'colossalai.core.global_context.is_initialized', 'gpc.is_initialized', (['ParallelMode.DATA'], {}), '(ParallelMode.DATA)\n', (3595, 3614), True, 'from colossalai.core import global_context as gpc\n'), ((6054, 6082), 'torch.argmax', 'torch.argmax', (['logits'], {'dim': '(-1)'}), '(logits, dim=-1)\n', (60... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init as init
from torch import Tensor
from torch.nn.parameter import Parameter
from typing import Tuple
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core impo... | [
"colossalai.core.global_context.get_world_size",
"colossalai.utils.get_current_device"
] | [((1930, 1974), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.PARALLEL_1D'], {}), '(ParallelMode.PARALLEL_1D)\n', (1948, 1974), True, 'from colossalai.core import global_context as gpc\n'), ((2926, 2969), 'torch.nn.functional.linear', 'F.linear', (['input_parallel', 'self.weight... |
from cmath import e
import json
import os
import transformers
import torch
import numpy as np
from data import get_train_features, gen_tensor_dataset, convert_examples_to_features
from metrics import compute_metrics
from tqdm import trange, tqdm
from colossalai.core import global_context as gpc
from torch.utils.data ... | [
"colossalai.nn.lr_scheduler.LinearWarmupLR",
"colossalai.nn.optimizer.FusedAdam",
"colossalai.utils.get_dataloader",
"colossalai.core.global_context.get_global_rank"
] | [((778, 829), 'transformers.BertConfig.from_json_file', 'transformers.BertConfig.from_json_file', (['config_file'], {}), '(config_file)\n', (816, 829), False, 'import transformers\n'), ((1644, 1720), 'colossalai.nn.optimizer.FusedAdam', 'FusedAdam', ([], {'params': 'optimizer_grouped_parameters', 'lr': 'lr', 'bias_corr... |
import torch
import torch.distributed as dist
from colossalai.core import global_context as gpc
from colossalai.context import ParallelMode
from functools import partial
from colossalai.zero.utils.zero_hook_v2 import ZeROHookV2
from colossalai.tensor.chunk import ChunkManager, TensorState
from colossalai.tensor.param_o... | [
"colossalai.core.global_context.get_world_size",
"colossalai.tensor.param_op_hook.use_param_op_hooks",
"colossalai.zero.utils.zero_hook_v2.ZeROHookV2",
"colossalai.core.global_context.get_group"
] | [((919, 938), 'torch.cuda.Stream', 'torch.cuda.Stream', ([], {}), '()\n', (936, 938), False, 'import torch\n'), ((968, 1005), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.DATA'], {}), '(ParallelMode.DATA)\n', (986, 1005), True, 'from colossalai.core import global_context as gpc... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import colossalai
import logging
from pathlib import Path
from typing import Union, List
import inspect
from colossalai.context.parallel_mode import ParallelMode
try:
from rich.logging import RichHandler
_FORMAT = 'colossalai - %(name)s - %(levelname)s: %(messa... | [
"colossalai.core.global_context.is_initialized",
"colossalai.core.global_context.get_global_rank",
"colossalai.core.global_context.get_local_rank"
] | [((601, 656), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '_FORMAT'}), '(level=logging.INFO, format=_FORMAT)\n', (620, 656), False, 'import logging\n'), ((2074, 2089), 'inspect.stack', 'inspect.stack', ([], {}), '()\n', (2087, 2089), False, 'import inspect\n'), ((4017, 4048), ... |
import torch
import torch.nn as nn
from colossalai.core import global_context as gpc
from colossalai.context import ParallelMode
from colossalai.logging import get_dist_logger
import torch.nn.functional as F
import torch.distributed as dist
from .cross_entropy import vocab_cross_entropy
class BertLoss(nn.Module):
... | [
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.get_group"
] | [((762, 798), 'colossalai.core.global_context.get_group', 'gpc.get_group', (['ParallelMode.SEQUENCE'], {}), '(ParallelMode.SEQUENCE)\n', (775, 798), True, 'from colossalai.core import global_context as gpc\n'), ((1116, 1157), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.SEQUENC... |
from copy import deepcopy
from functools import partial
import colossalai
import pytest
import torch
import torch.multiprocessing as mp
from colossalai.testing import parameterize
from colossalai.utils import free_port
from colossalai.zero.shard_utils import (BucketTensorShardStrategy, TensorShardStrategy)
from coloss... | [
"colossalai.testing.parameterize",
"colossalai.launch",
"colossalai.testing.rerun_on_exception",
"colossalai.utils.free_port",
"colossalai.zero.sharded_param.sharded_param.ShardedParamV2"
] | [((555, 645), 'colossalai.testing.parameterize', 'parameterize', (['"""shard_strategy_class"""', '[TensorShardStrategy, BucketTensorShardStrategy]'], {}), "('shard_strategy_class', [TensorShardStrategy,\n BucketTensorShardStrategy])\n", (567, 645), False, 'from colossalai.testing import parameterize\n'), ((1403, 144... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import os
from pathlib import Path
import pytest
import torch.autograd
import colossalai
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.engine import Engine
from colossalai.logging import get_... | [
"colossalai.nn.layer._parallel_utilities._gather",
"colossalai.initialize",
"colossalai.logging.get_global_dist_logger",
"colossalai.engine.Engine"
] | [((1573, 1688), 'pytest.mark.skip', 'pytest.mark.skip', (['"""This test should be invoked by test.sh in the same folder as it runs on multiple gpus"""'], {}), "(\n 'This test should be invoked by test.sh in the same folder as it runs on multiple gpus'\n )\n", (1589, 1688), False, 'import pytest\n'), ((1831, 1865)... |
from typing import List, Optional
import torch
import torch.distributed as dist
from colossalai.utils import get_current_device
from colossalai.zero.sharded_param.sharded_tensor import ShardedTensor
from torch._utils import _flatten_dense_tensors as flatten
from .tensor_shard_strategy import TensorShardStrategy
cla... | [
"colossalai.utils.get_current_device"
] | [((1208, 1242), 'torch.distributed.get_world_size', 'dist.get_world_size', (['process_group'], {}), '(process_group)\n', (1227, 1242), True, 'import torch.distributed as dist\n'), ((1258, 1286), 'torch.distributed.get_rank', 'dist.get_rank', (['process_group'], {}), '(process_group)\n', (1271, 1286), True, 'import torc... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import os.path as osp
from colossalai.registry import HOOKS
from colossalai.trainer import Trainer
from colossalai.trainer.hooks import BaseHook
from colossalai.utils import is_dp_rank_0
from colossalai.utils.checkpointing import get_latest_checkpoint_path, get_checkpoi... | [
"colossalai.utils.checkpointing.save_checkpoint",
"colossalai.utils.checkpointing.get_latest_checkpoint_path",
"colossalai.utils.is_dp_rank_0",
"colossalai.utils.checkpointing.get_checkpoint_path",
"colossalai.utils.checkpointing.load_checkpoint"
] | [((4816, 4832), 'os.path.exists', 'osp.exists', (['path'], {}), '(path)\n', (4826, 4832), True, 'import os.path as osp\n'), ((2172, 2186), 'colossalai.utils.is_dp_rank_0', 'is_dp_rank_0', ([], {}), '()\n', (2184, 2186), False, 'from colossalai.utils import is_dp_rank_0\n'), ((4624, 4691), 'colossalai.utils.checkpointin... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import os
import colossalai
import torch
import torchvision
from colossalai.builder import *
from colossalai.core import global_context as gpc
from colossalai.logging import get_dist_logger
from colossalai.nn import Accuracy, CrossEntropyLoss
from colossalai.nn.lr_sched... | [
"colossalai.trainer.hooks.LogMetricByEpochHook",
"colossalai.get_default_parser",
"colossalai.nn.lr_scheduler.CosineAnnealingWarmupLR",
"colossalai.trainer.hooks.LogMetricByStepHook",
"colossalai.utils.MultiTimer",
"colossalai.logging.get_dist_logger",
"colossalai.launch_from_torch",
"colossalai.utils... | [((1116, 1221), 'torchvision.datasets.CIFAR10', 'torchvision.datasets.CIFAR10', ([], {'root': 'DATASET_PATH', 'train': '(True)', 'download': '(True)', 'transform': 'transform_train'}), '(root=DATASET_PATH, train=True, download=True,\n transform=transform_train)\n', (1144, 1221), False, 'import torchvision\n'), ((138... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import torch.distributed as dist
from torchvision.datasets import Caltech101
from colossalai.context import ParallelMode
from colossalai.core import global_context as gpc
from colossalai.registry import DATASETS
from .base_dataset import BaseDataset
@DATASETS.register... | [
"colossalai.core.global_context.get_global_rank",
"colossalai.core.global_context.is_initialized"
] | [((881, 944), 'torchvision.datasets.Caltech101', 'Caltech101', (['*args'], {'transform': 'self._transform_pipeline'}), '(*args, transform=self._transform_pipeline, **kwargs)\n', (891, 944), False, 'from torchvision.datasets import Caltech101\n'), ((758, 797), 'colossalai.core.global_context.is_initialized', 'gpc.is_ini... |
import math
from typing import Callable
from colossalai.utils import get_current_device
from torch import dtype, nn
from ... import init as init
from ..parallel_1d import Embedding1D, PatchEmbedding1D, VocabParallelEmbedding1D
from ..parallel_2d import Embedding2D, PatchEmbedding2D, VocabParallelEmbedding2D
... | [
"colossalai.utils.get_current_device"
] | [((3478, 3498), 'colossalai.utils.get_current_device', 'get_current_device', ([], {}), '()\n', (3496, 3498), False, 'from colossalai.utils import get_current_device\n'), ((5654, 5666), 'math.sqrt', 'math.sqrt', (['(5)'], {}), '(5)\n', (5663, 5666), False, 'import math\n'), ((3345, 3434), 'torch.nn.Embedding', 'nn.Embed... |
import torch.distributed as dist
from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
from colossalai.core import global_context as gpc
from colossalai.registry import GRADIENT_HANDLER
from colossalai.global_variables import moe_env
from ._base_gradient_handler import BaseGradientHandler
from... | [
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.get_group"
] | [((1975, 2004), 'torch._utils._flatten_dense_tensors', '_flatten_dense_tensors', (['grads'], {}), '(grads)\n', (1997, 2004), False, 'from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors\n'), ((2035, 2072), 'colossalai.core.global_context.get_world_size', 'gpc.get_world_size', (['ParallelMode.DATA']... |
from colossalai.utils import get_current_device
from torch import nn
from colossalai import kernel
from ... import init as init
from ..parallel_1d import *
from ..parallel_2d import *
from ..parallel_2p5d import *
from ..parallel_3d import *
from ..utils import get_tensor_parallel_mode
from ..vanilla import ... | [
"colossalai.utils.get_current_device"
] | [((1445, 1465), 'colossalai.utils.get_current_device', 'get_current_device', ([], {}), '()\n', (1463, 1465), False, 'from colossalai.utils import get_current_device\n'), ((1392, 1431), 'torch.nn.LayerNorm', 'nn.LayerNorm', (['normalized_shape'], {'eps': 'eps'}), '(normalized_shape, eps=eps)\n', (1404, 1431), False, 'fr... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from copy import deepcopy
from functools import partial
import colossalai
import pytest
import torch
import torch.multiprocessing as mp
from colossalai.utils import free_port
from colossalai.zero.shard_utils import (BucketTensorShardStrategy, TensorShardStrategy)
from c... | [
"colossalai.launch",
"colossalai.utils.free_port"
] | [((1288, 1333), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""world_size"""', '[1, 2]'], {}), "('world_size', [1, 2])\n", (1311, 1333), False, 'import pytest\n'), ((1335, 1430), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shard_strategy"""', '[TensorShardStrategy, BucketTensorShardStrategy... |
import os
from typing import Callable, List, Optional, Type, Union
import torch
import torch.nn as nn
import colossalai
import colossalai.nn as col_nn
from colossalai.core import global_context as gpc
from colossalai.logging import disable_existing_loggers, get_dist_logger
from colossalai.trainer import Trainer, hooks... | [
"colossalai.trainer.hooks.LogMetricByEpochHook",
"colossalai.get_default_parser",
"colossalai.utils.model.pipelinable.PipelinableContext",
"colossalai.nn.lr_scheduler.LinearWarmupLR",
"colossalai.nn.metric.Accuracy",
"colossalai.utils.MultiTimer",
"colossalai.logging.get_dist_logger",
"colossalai.core... | [((785, 811), 'colossalai.logging.disable_existing_loggers', 'disable_existing_loggers', ([], {}), '()\n', (809, 811), False, 'from colossalai.logging import disable_existing_loggers, get_dist_logger\n'), ((825, 856), 'colossalai.get_default_parser', 'colossalai.get_default_parser', ([], {}), '()\n', (854, 856), False,... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from pathlib import Path
import pytest
import torch
from colossalai.builder import build_model
from colossalai.context import Config
CONFIG_PATH = Path(__file__).parent.joinpath('configs/vanilla_vit.py')
@pytest.mark.cpu
def test_with_vanilla_vit_config():
confi... | [
"colossalai.builder.build_model",
"colossalai.context.Config.from_file"
] | [((324, 353), 'colossalai.context.Config.from_file', 'Config.from_file', (['CONFIG_PATH'], {}), '(CONFIG_PATH)\n', (340, 353), False, 'from colossalai.context import Config\n'), ((366, 391), 'colossalai.builder.build_model', 'build_model', (['config.model'], {}), '(config.model)\n', (377, 391), False, 'from colossalai.... |
import torch.nn as nn
from torch.optim import Optimizer
from colossalai.utils import is_no_pp_or_last_stage
from .naive_amp import NaiveAMPOptimizer, NaiveAMPModel
def convert_to_naive_amp(model: nn.Module,
optimizer: Optimizer,
amp_config):
"""A helper function ... | [
"colossalai.utils.is_no_pp_or_last_stage"
] | [((732, 756), 'colossalai.utils.is_no_pp_or_last_stage', 'is_no_pp_or_last_stage', ([], {}), '()\n', (754, 756), False, 'from colossalai.utils import is_no_pp_or_last_stage\n')] |
import torch
from colossalai.tensor import ColoTensor
from numpy import allclose
def test_tensor_indexing():
torch_t = torch.randn(2, 3)
colo_t = ColoTensor.init_from_torch_tensor(torch_t)
assert allclose(torch_t[:, 1], colo_t[:, 1].torch_tensor())
def test_lazy_init_tensor():
lazy_t = ColoTensor(2,... | [
"colossalai.tensor.ColoTensor",
"colossalai.tensor.ColoTensor.init_from_torch_tensor"
] | [((125, 142), 'torch.randn', 'torch.randn', (['(2)', '(3)'], {}), '(2, 3)\n', (136, 142), False, 'import torch\n'), ((156, 198), 'colossalai.tensor.ColoTensor.init_from_torch_tensor', 'ColoTensor.init_from_torch_tensor', (['torch_t'], {}), '(torch_t)\n', (189, 198), False, 'from colossalai.tensor import ColoTensor\n'),... |
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Union, List
from colossalai.core import global_context as gpc
# copied from high version pytorch to support low version
def _format_time(time_us):
"""Defines how to format time in FunctionEvent"""
US_IN_SECOND = 1000.0 * ... | [
"colossalai.core.global_context.get_global_rank"
] | [((3634, 3647), 'pathlib.Path', 'Path', (['log_dir'], {}), '(log_dir)\n', (3638, 3647), False, 'from pathlib import Path\n'), ((3838, 3859), 'colossalai.core.global_context.get_global_rank', 'gpc.get_global_rank', ([], {}), '()\n', (3857, 3859), True, 'from colossalai.core import global_context as gpc\n')] |
import torch
import os
import pickle
from colossalai.logging import get_dist_logger
from colossalai.core import global_context as gpc
from torch.utils.data import TensorDataset
from processors import convert_examples_to_features
def gen_tensor_dataset(features):
all_input_ids = torch.tensor(
[f.input_ids ... | [
"colossalai.core.global_context.get_global_rank",
"colossalai.logging.get_dist_logger"
] | [((285, 348), 'torch.tensor', 'torch.tensor', (['[f.input_ids for f in features]'], {'dtype': 'torch.long'}), '([f.input_ids for f in features], dtype=torch.long)\n', (297, 348), False, 'import torch\n'), ((393, 457), 'torch.tensor', 'torch.tensor', (['[f.input_mask for f in features]'], {'dtype': 'torch.long'}), '([f.... |
from functools import partial
import torch
import torch.distributed as dist
from colossalai.logging import get_dist_logger
from colossalai.utils import checkpoint
from colossalai.zero.shard_utils import TensorShardStrategy
from colossalai.zero.sharded_model import ShardedModelV2
LOGGER = get_dist_logger('zero_test')
... | [
"colossalai.zero.shard_utils.TensorShardStrategy",
"colossalai.logging.get_dist_logger"
] | [((291, 319), 'colossalai.logging.get_dist_logger', 'get_dist_logger', (['"""zero_test"""'], {}), "('zero_test')\n", (306, 319), False, 'from colossalai.logging import get_dist_logger\n'), ((2906, 2940), 'torch.allclose', 'torch.allclose', (['tensor_a', 'tensor_b'], {}), '(tensor_a, tensor_b)\n', (2920, 2940), False, '... |
from pathlib import Path
from colossalai.logging import get_dist_logger
import colossalai
import torch
import os
from colossalai.core import global_context as gpc
from colossalai.utils import get_dataloader
from torchvision import transforms
from colossalai.nn.lr_scheduler import CosineAnnealingLR
from torchvision.data... | [
"colossalai.utils.get_dataloader",
"colossalai.launch_from_torch",
"colossalai.nn.lr_scheduler.CosineAnnealingLR",
"colossalai.initialize",
"colossalai.logging.get_dist_logger"
] | [((420, 470), 'colossalai.launch_from_torch', 'colossalai.launch_from_torch', ([], {'config': '"""./config.py"""'}), "(config='./config.py')\n", (448, 470), False, 'import colossalai\n'), ((485, 502), 'colossalai.logging.get_dist_logger', 'get_dist_logger', ([], {}), '()\n', (500, 502), False, 'from colossalai.logging ... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import logging
from pathlib import Path
from colossalai.context.parallel_mode import ParallelMode
from colossalai.core import global_context as gpc
_FORMAT = 'colossalai - %(name)s - %(asctime)s %(levelname)s: %(message)s'
logging.basicConfig(level=logging.INFO, format... | [
"colossalai.core.global_context.get_local_rank"
] | [((274, 329), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '_FORMAT'}), '(level=logging.INFO, format=_FORMAT)\n', (293, 329), False, 'import logging\n'), ((952, 975), 'logging.getLogger', 'logging.getLogger', (['name'], {}), '(name)\n', (969, 975), False, 'import logging\n'), (... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import math
from typing import Callable, Tuple
import torch
import torch.nn.functional as F
from colossalai.communication import broadcast
from colossalai.context import ParallelMode, seed
from colossalai.core import global_context as gpc
from colossalai.global_variable... | [
"colossalai.nn.init.normal_",
"colossalai.core.global_context.get_world_size",
"colossalai.core.global_context.get_ranks_in_group",
"colossalai.nn.init.xavier_uniform_",
"colossalai.utils.cuda.get_current_device",
"colossalai.context.seed",
"colossalai.core.global_context.get_local_rank"
] | [((2221, 2255), 'colossalai.nn.init.xavier_uniform_', 'init.xavier_uniform_', ([], {'a': '(1)', 'scale': '(1)'}), '(a=1, scale=1)\n', (2241, 2255), True, 'from colossalai.nn import init as init\n'), ((4862, 4896), 'colossalai.nn.init.xavier_uniform_', 'init.xavier_uniform_', ([], {'a': '(1)', 'scale': '(1)'}), '(a=1, s... |
from pathlib import Path
from colossalai.logging import get_dist_logger
import colossalai
import torch
import os
from colossalai.core import global_context as gpc
from colossalai.utils import get_dataloader, MultiTimer
from torchvision import transforms
from colossalai.trainer import hooks, Trainer
from torchvision.dat... | [
"colossalai.trainer.hooks.LogMemoryByEpochHook",
"colossalai.trainer.hooks.LogMetricByEpochHook",
"colossalai.trainer.hooks.LogTimingByEpochHook",
"colossalai.trainer.hooks.AccuracyHook",
"colossalai.utils.MultiTimer",
"colossalai.logging.get_dist_logger",
"colossalai.utils.get_dataloader",
"colossala... | [((465, 550), 'colossalai.launch_from_torch', 'colossalai.launch_from_torch', ([], {'config': '"""./config.py"""', 'host': '"""localhost"""', 'port': '(29500)'}), "(config='./config.py', host='localhost', port=29500\n )\n", (493, 550), False, 'import colossalai\n'), ((626, 643), 'colossalai.logging.get_dist_logger',... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.