Dataset Viewer
library
stringclasses 1
value | test_file
stringclasses 785
values | test_function
stringlengths 1
295
| before
stringlengths 0
448k
| after
stringlengths 0
487k
| context_before
stringclasses 947
values | context_after
stringlengths 0
16.3k
| commit_before
stringclasses 1
value | commit_after
stringclasses 1
value | change_type
stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|
torch
|
test/ao/sparsity/test_activation_sparsifier.py
|
__init__
|
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
self.conv2 = nn.Conv2d(32, 32, kernel_size=3)
self.identity1 = nn.Identity()
self.max_pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.linear1 = nn.Linear(4608, 128)
self.identity2 = nn.Identity()
self.linear2 = nn.Linear(128, 10)
|
def __init__(self) -> None:
super().__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
self.conv2 = nn.Conv2d(32, 32, kernel_size=3)
self.identity1 = nn.Identity()
self.max_pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.linear1 = nn.Linear(4608, 128)
self.identity2 = nn.Identity()
self.linear2 = nn.Linear(128, 10)
|
import copy
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
import logging
import torch
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import ActivationSparsifier
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from typing import List
class Model(nn.Module):
|
import copy
import logging
from typing import List
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import (
ActivationSparsifier,
)
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
class Model(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_activation_sparsifier.py
|
_check_step
|
def _check_step(self, activation_sparsifier, data_agg_actual):
"""Checks if .step() works as expected. Specifically, checks if the mask is computed correctly.
Args:
activation_sparsifier (sparsifier object)
activation sparsifier object that is being tested.
data_agg_actual (torch tensor)
aggregated torch tensor
"""
model = activation_sparsifier.model
layer_name = module_to_fqn(model, model.conv1)
assert layer_name is not None
reduce_fn = activation_sparsifier.data_groups[layer_name]['reduce_fn']
data_reduce_actual = reduce_fn(data_agg_actual)
mask_fn = activation_sparsifier.data_groups[layer_name]['mask_fn']
sparse_config = activation_sparsifier.data_groups[layer_name]['sparse_config']
mask_actual = mask_fn(data_reduce_actual, **sparse_config)
mask_model = activation_sparsifier.get_mask(layer_name)
assert torch.all(mask_model == mask_actual)
for _, config in activation_sparsifier.data_groups.items():
assert 'data' not in config
|
def _check_step(self, activation_sparsifier, data_agg_actual):
"""Checks if .step() works as expected. Specifically, checks if the mask is computed correctly.
Args:
activation_sparsifier (sparsifier object)
activation sparsifier object that is being tested.
data_agg_actual (torch tensor)
aggregated torch tensor
"""
model = activation_sparsifier.model
layer_name = module_to_fqn(model, model.conv1)
assert layer_name is not None
reduce_fn = activation_sparsifier.data_groups[layer_name]["reduce_fn"]
data_reduce_actual = reduce_fn(data_agg_actual)
mask_fn = activation_sparsifier.data_groups[layer_name]["mask_fn"]
sparse_config = activation_sparsifier.data_groups[layer_name]["sparse_config"]
mask_actual = mask_fn(data_reduce_actual, **sparse_config)
mask_model = activation_sparsifier.get_mask(layer_name)
assert torch.all(mask_model == mask_actual)
for config in activation_sparsifier.data_groups.values():
assert "data" not in config
|
import copy
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
import logging
import torch
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import ActivationSparsifier
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from typing import List
class TestActivationSparsifier(TestCase):
|
import copy
import logging
from typing import List
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import (
ActivationSparsifier,
)
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
class TestActivationSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
__init__
|
def __init__(self):
super().__init__()
self.seq = nn.Sequential(
nn.Linear(37, 39)
)
self.linear = nn.Linear(39, 33)
self.head = nn.Linear(33, 13)
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class Model(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
deleted
|
||
torch
|
test/ao/sparsity/test_sparsifier.py
|
forward
|
def forward(self, x):
x = self.seq(x)
x = torch.relu(x)
x = self.linear(x)
x = torch.relu(x)
x = self.head(x)
return x
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class Model(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
deleted
|
||
torch
|
test/ao/sparsity/test_sparsifier.py
|
__init__
|
def __init__(self):
super().__init__()
self.seq = nn.Sequential(
nn.Linear(37, 39)
)
self.linear = nn.Linear(39, 33)
self.head = nn.Linear(33, 13)
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class Model(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
deleted
|
||
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_constructor
|
def test_constructor(self):
# Cannot instantiate the abstract base
self.assertRaises(TypeError, BaseSparsifier)
# Can instantiate the model with no configs
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, config=None)
assert len(sparsifier.groups) == 3
sparsifier.step()
# Can instantiate the model with configs
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
assert len(sparsifier.groups) == 1
assert sparsifier.groups[0]['tensor_fqn'] == 'linear.weight'
assert 'test' in sparsifier.groups[0]
assert sparsifier.groups[0]['test'] == 3
|
def test_constructor(self):
# Cannot instantiate the abstract base
self.assertRaises(TypeError, BaseSparsifier)
# Can instantiate the model with no configs
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, config=None)
assert len(sparsifier.groups) == 5
sparsifier.step()
# Can instantiate the model with configs
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
assert len(sparsifier.groups) == 1
assert sparsifier.groups[0]["tensor_fqn"] == "linear1.weight"
assert "test" in sparsifier.groups[0]
assert sparsifier.groups[0]["test"] == 3
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_step_2_of_4
|
def test_step_2_of_4(self):
model = Model()
sparsifier = WeightNormSparsifier(sparsity_level=1.0,
sparse_block_shape=(1, 4),
zeros_per_block=2)
sparsifier.prepare(model, config=[{'tensor_fqn': 'linear.weight'}])
sparsifier.step()
# make sure the sparsity level is approximately 50%
mask = model.linear.parametrizations['weight'][0].mask.to(torch.float) # mean works on float only
self.assertAlmostEqual(mask.mean().item(), 0.5, places=2)
# Make sure each block has exactly 50% zeros
module = sparsifier.groups[0]['module']
mask = module.parametrizations['weight'][0].mask
for row in mask:
for idx in range(0, len(row), 4):
block = row[idx:idx + 4]
block, _ = block.sort()
assert (block[:2] == 0).all()
assert (block[2:] != 0).all()
|
def test_step_2_of_4(self):
model = SimpleLinear()
sparsifier = WeightNormSparsifier(
sparsity_level=1.0, sparse_block_shape=(1, 4), zeros_per_block=2
)
sparsifier.prepare(model, config=[{"tensor_fqn": "linear1.weight"}])
sparsifier.step()
# make sure the sparsity level is approximately 50%
mask = model.linear1.parametrizations["weight"][0].mask.to(
torch.float
) # mean works on float only
self.assertAlmostEqual(mask.mean().item(), 0.5, places=2)
# Make sure each block has exactly 50% zeros
module = sparsifier.groups[0]["module"]
mask = module.parametrizations["weight"][0].mask
for row in mask:
for idx in range(0, len(row), 4):
block = row[idx : idx + 4]
block, _ = block.sort()
assert (block[:2] == 0).all()
assert (block[2:] != 0).all()
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestWeightNormSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestWeightNormSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_prepare
|
def test_prepare(self):
model = Model()
sparsifier = WeightNormSparsifier()
sparsifier.prepare(model, config=None)
for g in sparsifier.groups:
module = g['module']
# Check mask exists
assert hasattr(module.parametrizations['weight'][0], 'mask')
# Check parametrization exists and is correct
assert is_parametrized(module, 'weight')
assert type(module.parametrizations.weight[0]) == FakeSparsity
|
def test_prepare(self):
model = SimpleLinear()
sparsifier = WeightNormSparsifier()
sparsifier.prepare(model, config=None)
for g in sparsifier.groups:
module = g["module"]
# Check mask exists
assert hasattr(module.parametrizations["weight"][0], "mask")
# Check parametrization exists and is correct
assert is_parametrized(module, "weight")
assert type(module.parametrizations.weight[0]) == FakeSparsity
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestWeightNormSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestWeightNormSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_mask_squash
|
def test_mask_squash(self):
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
assert hasattr(model.linear.parametrizations.weight[0], 'mask')
assert is_parametrized(model.linear, 'weight')
assert not is_parametrized(model.seq[0], 'weight')
sparsifier.squash_mask()
assert not is_parametrized(model.seq[0], 'weight')
assert not is_parametrized(model.linear, 'weight')
|
def test_mask_squash(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
assert hasattr(model.linear1.parametrizations.weight[0], "mask")
assert is_parametrized(model.linear1, "weight")
assert not is_parametrized(model.seq[0], "weight")
sparsifier.squash_mask()
assert not is_parametrized(model.seq[0], "weight")
assert not is_parametrized(model.linear1, "weight")
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_constructor
|
def test_constructor(self):
# Cannot instantiate the abstract base
self.assertRaises(TypeError, BaseSparsifier)
# Can instantiate the model with no configs
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, config=None)
assert len(sparsifier.groups) == 3
sparsifier.step()
# Can instantiate the model with configs
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
assert len(sparsifier.groups) == 1
assert sparsifier.groups[0]['tensor_fqn'] == 'linear.weight'
assert 'test' in sparsifier.groups[0]
assert sparsifier.groups[0]['test'] == 3
|
def test_constructor(self):
# Cannot instantiate the abstract base
self.assertRaises(TypeError, BaseSparsifier)
# Can instantiate the model with no configs
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, config=None)
assert len(sparsifier.groups) == 5
sparsifier.step()
# Can instantiate the model with configs
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
assert len(sparsifier.groups) == 1
assert sparsifier.groups[0]["tensor_fqn"] == "linear1.weight"
assert "test" in sparsifier.groups[0]
assert sparsifier.groups[0]["test"] == 3
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_step
|
def test_step(self):
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.enable_mask_update = True
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
sparsifier.step()
assert torch.all(model.linear.parametrizations.weight[0].mask[0] == 0)
|
def test_step(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.enable_mask_update = True
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
sparsifier.step()
assert torch.all(model.linear1.parametrizations.weight[0].mask[0] == 0)
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_prepare
|
def test_prepare(self):
model = Model()
sparsifier = WeightNormSparsifier()
sparsifier.prepare(model, config=None)
for g in sparsifier.groups:
module = g['module']
# Check mask exists
assert hasattr(module.parametrizations['weight'][0], 'mask')
# Check parametrization exists and is correct
assert is_parametrized(module, 'weight')
assert type(module.parametrizations.weight[0]) == FakeSparsity
|
def test_prepare(self):
model = SimpleLinear()
sparsifier = WeightNormSparsifier()
sparsifier.prepare(model, config=None)
for g in sparsifier.groups:
module = g["module"]
# Check mask exists
assert hasattr(module.parametrizations["weight"][0], "mask")
# Check parametrization exists and is correct
assert is_parametrized(module, "weight")
assert type(module.parametrizations.weight[0]) == FakeSparsity
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestWeightNormSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestWeightNormSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_mask_squash
|
def test_mask_squash(self):
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
assert hasattr(model.linear.parametrizations.weight[0], 'mask')
assert is_parametrized(model.linear, 'weight')
assert not is_parametrized(model.seq[0], 'weight')
sparsifier.squash_mask()
assert not is_parametrized(model.seq[0], 'weight')
assert not is_parametrized(model.linear, 'weight')
|
def test_mask_squash(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
assert hasattr(model.linear1.parametrizations.weight[0], "mask")
assert is_parametrized(model.linear1, "weight")
assert not is_parametrized(model.seq[0], "weight")
sparsifier.squash_mask()
assert not is_parametrized(model.seq[0], "weight")
assert not is_parametrized(model.linear1, "weight")
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_activation_sparsifier.py
|
test_activation_sparsifier
|
def test_activation_sparsifier(self):
"""Simulates the workflow of the activation sparsifier, starting from object creation
till squash_mask().
The idea is to check that everything works as expected while in the workflow.
"""
# defining aggregate, reduce and mask functions
def agg_fn(x, y):
return x + y
def reduce_fn(x):
return torch.mean(x, dim=0)
def _vanilla_norm_sparsifier(data, sparsity_level):
r"""Similar to data norm spasifier but block_shape = (1,1).
Simply, flatten the data, sort it and mask out the values less than threshold
"""
data_norm = torch.abs(data).flatten()
_, sorted_idx = torch.sort(data_norm)
threshold_idx = round(sparsity_level * len(sorted_idx))
sorted_idx = sorted_idx[:threshold_idx]
mask = torch.ones_like(data_norm)
mask.scatter_(dim=0, index=sorted_idx, value=0)
mask = mask.reshape(data.shape)
return mask
# Creating default function and sparse configs
# default sparse_config
sparse_config = {
'sparsity_level': 0.5
}
defaults = {
'aggregate_fn': agg_fn,
'reduce_fn': reduce_fn
}
# simulate the workflow
# STEP 1: make data and activation sparsifier object
model = Model() # create model
activation_sparsifier = ActivationSparsifier(model, **defaults, **sparse_config)
# Test Constructor
self._check_constructor(activation_sparsifier, model, defaults, sparse_config)
# STEP 2: Register some layers
register_layer1_args = {
'layer': model.conv1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer1 = {'sparsity_level': 0.3}
register_layer2_args = {
'layer': model.linear1,
'features': [0, 10, 234],
'feature_dim': 1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer2 = {'sparsity_level': 0.1}
register_layer3_args = {
'layer': model.identity1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer3 = {'sparsity_level': 0.3}
register_layer4_args = {
'layer': model.identity2,
'features': [0, 10, 20],
'feature_dim': 1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer4 = {'sparsity_level': 0.1}
layer_args_list = [(register_layer1_args, sparse_config_layer1), (register_layer2_args, sparse_config_layer2)]
layer_args_list += [(register_layer3_args, sparse_config_layer3), (register_layer4_args, sparse_config_layer4)]
# Registering..
for layer_args in layer_args_list:
layer_arg, sparse_config_layer = layer_args
activation_sparsifier.register_layer(**layer_arg, **sparse_config_layer)
# check if things are registered correctly
self._check_register_layer(activation_sparsifier, defaults, sparse_config, layer_args_list)
# check state_dict after registering and before model forward
self._check_state_dict(activation_sparsifier)
# check if forward pre hooks actually work
# some dummy data
data_list = []
num_data_points = 5
for _ in range(0, num_data_points):
rand_data = torch.randn(16, 1, 28, 28)
activation_sparsifier.model(rand_data)
data_list.append(rand_data)
data_agg_actual = self._check_pre_forward_hook(activation_sparsifier, data_list)
# check state_dict() before step()
self._check_state_dict(activation_sparsifier)
# STEP 3: sparsifier step
activation_sparsifier.step()
# check state_dict() after step() and before squash_mask()
self._check_state_dict(activation_sparsifier)
# self.check_step()
self._check_step(activation_sparsifier, data_agg_actual)
# STEP 4: squash mask
activation_sparsifier.squash_mask()
self._check_squash_mask(activation_sparsifier, data_list[0])
# check state_dict() after squash_mask()
self._check_state_dict(activation_sparsifier)
|
def test_activation_sparsifier(self):
"""Simulates the workflow of the activation sparsifier, starting from object creation
till squash_mask().
The idea is to check that everything works as expected while in the workflow.
"""
# defining aggregate, reduce and mask functions
def agg_fn(x, y):
return x + y
def reduce_fn(x):
return torch.mean(x, dim=0)
def _vanilla_norm_sparsifier(data, sparsity_level):
r"""Similar to data norm sparsifier but block_shape = (1,1).
Simply, flatten the data, sort it and mask out the values less than threshold
"""
data_norm = torch.abs(data).flatten()
_, sorted_idx = torch.sort(data_norm)
threshold_idx = round(sparsity_level * len(sorted_idx))
sorted_idx = sorted_idx[:threshold_idx]
mask = torch.ones_like(data_norm)
mask.scatter_(dim=0, index=sorted_idx, value=0)
mask = mask.reshape(data.shape)
return mask
# Creating default function and sparse configs
# default sparse_config
sparse_config = {"sparsity_level": 0.5}
defaults = {"aggregate_fn": agg_fn, "reduce_fn": reduce_fn}
# simulate the workflow
# STEP 1: make data and activation sparsifier object
model = Model() # create model
activation_sparsifier = ActivationSparsifier(model, **defaults, **sparse_config)
# Test Constructor
self._check_constructor(activation_sparsifier, model, defaults, sparse_config)
# STEP 2: Register some layers
register_layer1_args = {
"layer": model.conv1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer1 = {"sparsity_level": 0.3}
register_layer2_args = {
"layer": model.linear1,
"features": [0, 10, 234],
"feature_dim": 1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer2 = {"sparsity_level": 0.1}
register_layer3_args = {
"layer": model.identity1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer3 = {"sparsity_level": 0.3}
register_layer4_args = {
"layer": model.identity2,
"features": [0, 10, 20],
"feature_dim": 1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer4 = {"sparsity_level": 0.1}
layer_args_list = [
(register_layer1_args, sparse_config_layer1),
(register_layer2_args, sparse_config_layer2),
]
layer_args_list += [
(register_layer3_args, sparse_config_layer3),
(register_layer4_args, sparse_config_layer4),
]
# Registering..
for layer_args in layer_args_list:
layer_arg, sparse_config_layer = layer_args
activation_sparsifier.register_layer(**layer_arg, **sparse_config_layer)
# check if things are registered correctly
self._check_register_layer(
activation_sparsifier, defaults, sparse_config, layer_args_list
)
# check state_dict after registering and before model forward
self._check_state_dict(activation_sparsifier)
# check if forward pre hooks actually work
# some dummy data
data_list = []
num_data_points = 5
for _ in range(0, num_data_points):
rand_data = torch.randn(16, 1, 28, 28)
activation_sparsifier.model(rand_data)
data_list.append(rand_data)
data_agg_actual = self._check_pre_forward_hook(activation_sparsifier, data_list)
# check state_dict() before step()
self._check_state_dict(activation_sparsifier)
# STEP 3: sparsifier step
activation_sparsifier.step()
# check state_dict() after step() and before squash_mask()
self._check_state_dict(activation_sparsifier)
# self.check_step()
self._check_step(activation_sparsifier, data_agg_actual)
# STEP 4: squash mask
activation_sparsifier.squash_mask()
self._check_squash_mask(activation_sparsifier, data_list[0])
# check state_dict() after squash_mask()
self._check_state_dict(activation_sparsifier)
|
import copy
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
import logging
import torch
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import ActivationSparsifier
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from typing import List
class TestActivationSparsifier(TestCase):
|
import copy
import logging
from typing import List
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import (
ActivationSparsifier,
)
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
class TestActivationSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_activation_sparsifier.py
|
_vanilla_norm_sparsifier
|
def _vanilla_norm_sparsifier(data, sparsity_level):
r"""Similar to data norm spasifier but block_shape = (1,1).
Simply, flatten the data, sort it and mask out the values less than threshold
"""
data_norm = torch.abs(data).flatten()
_, sorted_idx = torch.sort(data_norm)
threshold_idx = round(sparsity_level * len(sorted_idx))
sorted_idx = sorted_idx[:threshold_idx]
mask = torch.ones_like(data_norm)
mask.scatter_(dim=0, index=sorted_idx, value=0)
mask = mask.reshape(data.shape)
return mask
# Creating default function and sparse configs
# default sparse_config
sparse_config = {
'sparsity_level': 0.5
}
defaults = {
'aggregate_fn': agg_fn,
'reduce_fn': reduce_fn
}
# simulate the workflow
# STEP 1: make data and activation sparsifier object
model = Model() # create model
activation_sparsifier = ActivationSparsifier(model, **defaults, **sparse_config)
# Test Constructor
self._check_constructor(activation_sparsifier, model, defaults, sparse_config)
# STEP 2: Register some layers
register_layer1_args = {
'layer': model.conv1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer1 = {'sparsity_level': 0.3}
register_layer2_args = {
'layer': model.linear1,
'features': [0, 10, 234],
'feature_dim': 1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer2 = {'sparsity_level': 0.1}
register_layer3_args = {
'layer': model.identity1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer3 = {'sparsity_level': 0.3}
register_layer4_args = {
'layer': model.identity2,
'features': [0, 10, 20],
'feature_dim': 1,
'mask_fn': _vanilla_norm_sparsifier
}
sparse_config_layer4 = {'sparsity_level': 0.1}
layer_args_list = [(register_layer1_args, sparse_config_layer1), (register_layer2_args, sparse_config_layer2)]
layer_args_list += [(register_layer3_args, sparse_config_layer3), (register_layer4_args, sparse_config_layer4)]
# Registering..
for layer_args in layer_args_list:
layer_arg, sparse_config_layer = layer_args
activation_sparsifier.register_layer(**layer_arg, **sparse_config_layer)
# check if things are registered correctly
self._check_register_layer(activation_sparsifier, defaults, sparse_config, layer_args_list)
# check state_dict after registering and before model forward
self._check_state_dict(activation_sparsifier)
# check if forward pre hooks actually work
# some dummy data
data_list = []
num_data_points = 5
for _ in range(0, num_data_points):
rand_data = torch.randn(16, 1, 28, 28)
activation_sparsifier.model(rand_data)
data_list.append(rand_data)
data_agg_actual = self._check_pre_forward_hook(activation_sparsifier, data_list)
# check state_dict() before step()
self._check_state_dict(activation_sparsifier)
# STEP 3: sparsifier step
activation_sparsifier.step()
# check state_dict() after step() and before squash_mask()
self._check_state_dict(activation_sparsifier)
# self.check_step()
self._check_step(activation_sparsifier, data_agg_actual)
# STEP 4: squash mask
activation_sparsifier.squash_mask()
self._check_squash_mask(activation_sparsifier, data_list[0])
# check state_dict() after squash_mask()
self._check_state_dict(activation_sparsifier)
|
def _vanilla_norm_sparsifier(data, sparsity_level):
r"""Similar to data norm sparsifier but block_shape = (1,1).
Simply, flatten the data, sort it and mask out the values less than threshold
"""
data_norm = torch.abs(data).flatten()
_, sorted_idx = torch.sort(data_norm)
threshold_idx = round(sparsity_level * len(sorted_idx))
sorted_idx = sorted_idx[:threshold_idx]
mask = torch.ones_like(data_norm)
mask.scatter_(dim=0, index=sorted_idx, value=0)
mask = mask.reshape(data.shape)
return mask
# Creating default function and sparse configs
# default sparse_config
sparse_config = {"sparsity_level": 0.5}
defaults = {"aggregate_fn": agg_fn, "reduce_fn": reduce_fn}
# simulate the workflow
# STEP 1: make data and activation sparsifier object
model = Model() # create model
activation_sparsifier = ActivationSparsifier(model, **defaults, **sparse_config)
# Test Constructor
self._check_constructor(activation_sparsifier, model, defaults, sparse_config)
# STEP 2: Register some layers
register_layer1_args = {
"layer": model.conv1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer1 = {"sparsity_level": 0.3}
register_layer2_args = {
"layer": model.linear1,
"features": [0, 10, 234],
"feature_dim": 1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer2 = {"sparsity_level": 0.1}
register_layer3_args = {
"layer": model.identity1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer3 = {"sparsity_level": 0.3}
register_layer4_args = {
"layer": model.identity2,
"features": [0, 10, 20],
"feature_dim": 1,
"mask_fn": _vanilla_norm_sparsifier,
}
sparse_config_layer4 = {"sparsity_level": 0.1}
layer_args_list = [
(register_layer1_args, sparse_config_layer1),
(register_layer2_args, sparse_config_layer2),
]
layer_args_list += [
(register_layer3_args, sparse_config_layer3),
(register_layer4_args, sparse_config_layer4),
]
# Registering..
for layer_args in layer_args_list:
layer_arg, sparse_config_layer = layer_args
activation_sparsifier.register_layer(**layer_arg, **sparse_config_layer)
# check if things are registered correctly
self._check_register_layer(
activation_sparsifier, defaults, sparse_config, layer_args_list
)
# check state_dict after registering and before model forward
self._check_state_dict(activation_sparsifier)
# check if forward pre hooks actually work
# some dummy data
data_list = []
num_data_points = 5
for _ in range(0, num_data_points):
rand_data = torch.randn(16, 1, 28, 28)
activation_sparsifier.model(rand_data)
data_list.append(rand_data)
data_agg_actual = self._check_pre_forward_hook(activation_sparsifier, data_list)
# check state_dict() before step()
self._check_state_dict(activation_sparsifier)
# STEP 3: sparsifier step
activation_sparsifier.step()
# check state_dict() after step() and before squash_mask()
self._check_state_dict(activation_sparsifier)
# self.check_step()
self._check_step(activation_sparsifier, data_agg_actual)
# STEP 4: squash mask
activation_sparsifier.squash_mask()
self._check_squash_mask(activation_sparsifier, data_list[0])
# check state_dict() after squash_mask()
self._check_state_dict(activation_sparsifier)
|
import copy
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
import logging
import torch
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import ActivationSparsifier
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from typing import List
|
import copy
import logging
from typing import List
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier import (
ActivationSparsifier,
)
from torch.ao.pruning.sparsifier.utils import module_to_fqn
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
test_saliency_pruner_update_mask
|
def test_saliency_pruner_update_mask(self):
"""Test that we prune out the row with the lowest saliency (first row)"""
model = SimpleLinear()
with torch.no_grad():
model.linear1.weight = nn.Parameter(
torch.Tensor([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]])
)
pruning_config = [{"tensor_fqn": "linear1.weight", "sparsity_level": 0.5}]
pruner = SaliencyPruner({})
pruner.prepare(model, pruning_config)
pruner.enable_mask_update = True
pruner.step()
pruned_model = pruner.prune()
expected = torch.Tensor([[2, 2, 2, 2], [3, 3, 3, 3]])
pruned = pruned_model.linear1.weight
assert expected.shape == pruned.shape
assert torch.isclose(expected, pruned, rtol=1e-05, atol=1e-07).all()
|
def test_saliency_pruner_update_mask(self):
"""Test that we prune out the row with the lowest saliency (first row)"""
model = SimpleLinear()
with torch.no_grad():
model.linear1.weight = nn.Parameter(
torch.Tensor([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
)
pruning_config = [{"tensor_fqn": "linear1.weight", "sparsity_level": 0.5}]
pruner = SaliencyPruner({})
pruner.prepare(model, pruning_config)
pruner.enable_mask_update = True
pruner.step()
pruned_model = pruner.prune()
expected = torch.Tensor([[3, 3, 3, 3], [4, 4, 4, 4]])
pruned = pruned_model.linear1.weight
assert expected.shape == pruned.shape
assert torch.isclose(expected, pruned, rtol=1e-05, atol=1e-07).all()
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
SaliencyPruner,
LSTMSaliencyPruner,
BaseStructuredSparsifier,
FakeStructuredSparsity,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
from torch.testing._internal.common_pruning import (
SimpleLinear,
LinearBias,
LinearActivation,
LinearActivationFunctional,
SimpleConv2d,
Conv2dBias,
Conv2dActivation,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LSTMLinearModel,
LSTMLayerNormLinearModel,
rows_are_subset,
)
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestSaliencyPruner(TestCase):
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestSaliencyPruner(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
_check_pruner_valid_before_step
|
def _check_pruner_valid_before_step(self, model, pruner, device):
for config in pruner.groups:
modules = []
if type(config["module"]) is tuple:
for module in config["module"]:
modules.append(module)
else:
module = config["module"]
modules.append(module)
for module in modules:
assert module.weight.device.type == device.type
assert module.parametrizations.weight[0].mask.dtype == torch.bool
|
def _check_pruner_valid_before_step(self, model, pruner, device):
for config in pruner.groups:
modules = []
if type(config["module"]) is tuple:
modules.extend(config["module"])
else:
module = config["module"]
modules.append(module)
for module in modules:
assert module.weight.device.type == device.type
assert module.parametrizations.weight[0].mask.dtype == torch.bool
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
SaliencyPruner,
LSTMSaliencyPruner,
BaseStructuredSparsifier,
FakeStructuredSparsity,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
from torch.testing._internal.common_pruning import (
SimpleLinear,
LinearBias,
LinearActivation,
LinearActivationFunctional,
SimpleConv2d,
Conv2dBias,
Conv2dActivation,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LSTMLinearModel,
LSTMLayerNormLinearModel,
rows_are_subset,
)
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestBaseStructuredSparsifier(TestCase):
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestBaseStructuredSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
_check_pruner_valid_after_step
|
def _check_pruner_valid_after_step(self, model, pruner, mask, device):
for config in pruner.groups:
modules = []
if type(config["module"]) is tuple:
for module in config["module"]:
modules.append(module)
else:
module = config["module"]
modules.append(module)
for module in modules:
assert module.weight.device.type == device.type
total = module.parametrizations.weight[0].mask.numel()
assert (
module.parametrizations.weight[0].mask.count_nonzero()
== total - mask
)
|
def _check_pruner_valid_after_step(self, model, pruner, mask, device):
for config in pruner.groups:
modules = []
if type(config["module"]) is tuple:
modules.extend(config["module"])
else:
module = config["module"]
modules.append(module)
for module in modules:
assert module.weight.device.type == device.type
total = module.parametrizations.weight[0].mask.numel()
assert (
module.parametrizations.weight[0].mask.count_nonzero()
== total - mask
)
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
SaliencyPruner,
LSTMSaliencyPruner,
BaseStructuredSparsifier,
FakeStructuredSparsity,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
from torch.testing._internal.common_pruning import (
SimpleLinear,
LinearBias,
LinearActivation,
LinearActivationFunctional,
SimpleConv2d,
Conv2dBias,
Conv2dActivation,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LSTMLinearModel,
LSTMLayerNormLinearModel,
rows_are_subset,
)
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestBaseStructuredSparsifier(TestCase):
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestBaseStructuredSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
_test_constructor_on_device
|
def _test_constructor_on_device(self, model, device):
self.assertRaisesRegex(
TypeError,
"BaseStructuredSparsifier.* update_mask",
BaseStructuredSparsifier,
)
model1 = copy.deepcopy(model).to(device)
pruner = SimplePruner(None)
pruner.prepare(model1, None)
pruner.enable_mask_update = True
for g in pruner.groups:
module = g["module"]
assert module.weight.device.type == device.type
assert len(pruner.groups) == 5
pruner.step()
# Can instantiate the model with configs
model2 = copy.deepcopy(model).to(device)
pruner = SimplePruner({"test": 3})
pruner.prepare(model2, [{"tensor_fqn": "seq.0.weight"}])
assert len(pruner.groups) == 1
assert pruner.groups[0]["module_fqn"] == "seq.0"
assert "test" in pruner.groups[0]
assert pruner.groups[0]["test"] == 3
|
def _test_constructor_on_device(self, model, device):
self.assertRaisesRegex(
TypeError,
"BaseStructuredSparsifier.*update_mask",
BaseStructuredSparsifier,
)
model1 = copy.deepcopy(model).to(device)
pruner = SimplePruner(None)
pruner.prepare(model1, None)
pruner.enable_mask_update = True
for g in pruner.groups:
module = g["module"]
assert module.weight.device.type == device.type
assert len(pruner.groups) == 5
pruner.step()
# Can instantiate the model with configs
model2 = copy.deepcopy(model).to(device)
pruner = SimplePruner({"test": 3})
pruner.prepare(model2, [{"tensor_fqn": "seq.0.weight"}])
assert len(pruner.groups) == 1
assert pruner.groups[0]["module_fqn"] == "seq.0"
assert "test" in pruner.groups[0]
assert pruner.groups[0]["test"] == 3
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
SaliencyPruner,
LSTMSaliencyPruner,
BaseStructuredSparsifier,
FakeStructuredSparsity,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_utils import TestCase, skipIfTorchDynamo
from torch.testing._internal.common_pruning import (
SimpleLinear,
LinearBias,
LinearActivation,
LinearActivationFunctional,
SimpleConv2d,
Conv2dBias,
Conv2dActivation,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LSTMLinearModel,
LSTMLayerNormLinearModel,
rows_are_subset,
)
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestBaseStructuredSparsifier(TestCase):
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestBaseStructuredSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_data_sparsifier.py
|
_get_bounds_on_actual_sparsity
|
def _get_bounds_on_actual_sparsity(config, tensor_shape):
r"""This function gets the bounds on actual sparsity.
Note::
Although we specify the sparsity_level parameter, this does not mean that
the actual sparsity obtained after sparsification is the same as sparsity_level.
The actual sparsity depends largely on the shape and the data itself.
"""
sparsity_level = config['sparsity_level']
zeros_per_block = config['zeros_per_block']
sparse_block_shape = config['sparse_block_shape']
height, width = tensor_shape[-2], tensor_shape[-1]
block_height, block_width = sparse_block_shape
number_blocks = math.ceil(height / block_height) * math.ceil(width / block_width)
values_per_block = block_height * block_width
if zeros_per_block == 0:
return (1.0, 1.0)
else:
# min value assumes zeros_per_block is 1
min_values_sparsified = round(number_blocks * sparsity_level)
# max value assumes actual zeros_per_block
max_values_sparsified = min_values_sparsified * min(values_per_block, zeros_per_block)
lower_bound = min_values_sparsified / (height * width)
upper_bound = min(1.0, max_values_sparsified / (height * width))
lower_bound, upper_bound = round(lower_bound, 3), round(upper_bound, 3)
return lower_bound, upper_bound
|
def _get_bounds_on_actual_sparsity(config, tensor_shape):
r"""This function gets the bounds on actual sparsity.
Note::
Although we specify the sparsity_level parameter, this does not mean that
the actual sparsity obtained after sparsification is the same as sparsity_level.
The actual sparsity depends largely on the shape and the data itself.
"""
sparsity_level = config["sparsity_level"]
zeros_per_block = config["zeros_per_block"]
sparse_block_shape = config["sparse_block_shape"]
height, width = tensor_shape[-2], tensor_shape[-1]
block_height, block_width = sparse_block_shape
number_blocks = math.ceil(height / block_height) * math.ceil(
width / block_width
)
values_per_block = block_height * block_width
if zeros_per_block == 0:
return (1.0, 1.0)
else:
# min value assumes zeros_per_block is 1
min_values_sparsified = round(number_blocks * sparsity_level)
# max value assumes actual zeros_per_block
max_values_sparsified = min_values_sparsified * min(
values_per_block, zeros_per_block
)
lower_bound = min_values_sparsified / (height * width)
upper_bound = min(1.0, max_values_sparsified / (height * width))
lower_bound, upper_bound = round(lower_bound, 3), round(upper_bound, 3)
return lower_bound, upper_bound
|
import logging
import torch
from torch.nn.utils.parametrize import is_parametrized
import unittest
from torch.testing._internal.common_utils import TestCase, TEST_WITH_ASAN
from typing import Tuple
from torch import nn
import itertools
import math
import copy
from torch.ao.pruning._experimental.data_sparsifier import BaseDataSparsifier, DataNormSparsifier
from torch.ao.pruning._experimental.data_sparsifier.quantization_utils import post_training_sparse_quantize
class _NormDataSparsifierTestCase(_BaseDataSparsiferTestCase):
|
import copy
import itertools
import logging
import math
from typing import Tuple
import torch
from torch import nn
from torch.ao.pruning._experimental.data_sparsifier import (
BaseDataSparsifier,
DataNormSparsifier,
)
from torch.ao.pruning._experimental.data_sparsifier.quantization_utils import (
post_training_sparse_quantize,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class _NormDataSparsifierTestCase(_BaseDataSparsiferTestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_prepare_config
|
def test_prepare_config(self):
model = Model()
sparsifier = ImplementedSparsifier(test=3)
# Make sure there are no parametrizations before `prepare`
assert not hasattr(model.seq[0], 'parametrizations')
assert not hasattr(model.linear, 'parametrizations')
assert not hasattr(model.head, 'parametrizations')
sparsifier.prepare(model, config=[
{'tensor_fqn': 'seq.0.weight', 'test': 42},
# No 'linear' to make sure it will be skipped in the sparsification
{'tensor_fqn': 'head.weight'}
])
assert len(sparsifier.groups) == 2
# Check if default argument is not assigned if explicit
assert sparsifier.groups[0]['tensor_fqn'] == 'seq.0.weight'
assert sparsifier.groups[0]['test'] == 42
# Check if FQN and module are pointing to the same location
assert sparsifier.groups[1]['tensor_fqn'] == 'head.weight'
assert sparsifier.groups[1]['module'] == model.head
# Check if parameterizations are attached
assert hasattr(model.seq[0], 'parametrizations')
assert not hasattr(model.linear, 'parametrizations')
assert hasattr(model.head, 'parametrizations')
|
def test_prepare_config(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
# Make sure there are no parametrizations before `prepare`
assert not hasattr(model.seq[0], "parametrizations")
assert not hasattr(model.linear1, "parametrizations")
assert not hasattr(model.linear2, "parametrizations")
sparsifier.prepare(
model,
config=[
{"tensor_fqn": "seq.0.weight", "test": 42},
# No 'linear1' to make sure it will be skipped in the sparsification
{"tensor_fqn": "linear2.weight"},
],
)
assert len(sparsifier.groups) == 2
# Check if default argument is not assigned if explicit
assert sparsifier.groups[0]["tensor_fqn"] == "seq.0.weight"
assert sparsifier.groups[0]["test"] == 42
# Check if FQN and module are pointing to the same location
assert sparsifier.groups[1]["tensor_fqn"] == "linear2.weight"
assert sparsifier.groups[1]["module"] == model.linear2
# Check if parameterizations are attached
assert hasattr(model.seq[0], "parametrizations")
assert not hasattr(model.linear1, "parametrizations")
assert hasattr(model.linear2, "parametrizations")
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_step
|
def test_step(self):
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.enable_mask_update = True
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
sparsifier.step()
assert torch.all(model.linear.parametrizations.weight[0].mask[0] == 0)
|
def test_step(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.enable_mask_update = True
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
sparsifier.step()
assert torch.all(model.linear1.parametrizations.weight[0].mask[0] == 0)
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_state_dict
|
def test_state_dict(self):
step_count = 3
model0 = Model()
sparsifier0 = ImplementedSparsifier(test=3)
sparsifier0.prepare(model0, [{'tensor_fqn': 'linear.weight'}])
mask = model0.linear.parametrizations['weight'][0].mask
mask.data = torch.arange(mask.shape[0] * mask.shape[1]).reshape(mask.shape)
for step in range(step_count):
sparsifier0.step()
state_dict = sparsifier0.state_dict()
# Check the expected keys in the state_dict
assert 'state' in state_dict
assert 'step_count' in state_dict['state']['linear.weight']
assert state_dict['state']['linear.weight']['step_count'] == 3
assert 'groups' in state_dict
assert 'test' in state_dict['groups'][0]
assert 'tensor_fqn' in state_dict['groups'][0]
assert state_dict['groups'][0]['tensor_fqn'] == 'linear.weight'
# Check loading static_dict creates an equivalent model
model1 = Model()
sparsifier1 = ImplementedSparsifier()
sparsifier1.prepare(model1, None)
assert sparsifier0.state != sparsifier1.state
# Make sure the masks are different in the beginning
for mg in sparsifier0.groups:
if mg['tensor_fqn'] == 'linear.weight':
mask0 = mg['module'].parametrizations.weight[0].mask
for mg in sparsifier1.groups:
if mg['tensor_fqn'] == 'linear.weight':
mask1 = mg['module'].parametrizations.weight[0].mask
self.assertNotEqual(mask0, mask1)
sparsifier1.load_state_dict(state_dict)
# Make sure the states are loaded, and are correct
assert sparsifier0.state == sparsifier1.state
# Make sure the masks (and all dicts) are the same after loading
assert len(sparsifier0.groups) == len(sparsifier1.groups)
for idx in range(len(sparsifier0.groups)):
mg0 = sparsifier0.groups[idx]
mg1 = sparsifier1.groups[idx]
for key in mg0.keys():
assert key in mg1
if key == 'module':
# We cannot compare modules as they are different
param0 = mg0[key].parametrizations.weight[0]
param1 = mg1[key].parametrizations.weight[0]
assert hasattr(param0, 'mask')
assert hasattr(param1, 'mask')
self.assertEqual(param0.__dict__, param1.__dict__)
else:
assert mg0[key] == mg1[key]
|
def test_state_dict(self):
step_count = 3
model0 = SimpleLinear()
sparsifier0 = ImplementedSparsifier(test=3)
sparsifier0.prepare(model0, [{"tensor_fqn": "linear1.weight"}])
mask = model0.linear1.parametrizations["weight"][0].mask
mask.data = torch.arange(mask.shape[0] * mask.shape[1]).reshape(mask.shape)
for step in range(step_count):
sparsifier0.step()
state_dict = sparsifier0.state_dict()
# Check the expected keys in the state_dict
assert "state" in state_dict
assert "step_count" in state_dict["state"]["linear1.weight"]
assert state_dict["state"]["linear1.weight"]["step_count"] == 3
assert "groups" in state_dict
assert "test" in state_dict["groups"][0]
assert "tensor_fqn" in state_dict["groups"][0]
assert state_dict["groups"][0]["tensor_fqn"] == "linear1.weight"
# Check loading static_dict creates an equivalent model
model1 = SimpleLinear()
sparsifier1 = ImplementedSparsifier()
sparsifier1.prepare(model1, None)
assert sparsifier0.state != sparsifier1.state
# Make sure the masks are different in the beginning
for mg in sparsifier0.groups:
if mg["tensor_fqn"] == "linear1.weight":
mask0 = mg["module"].parametrizations.weight[0].mask
for mg in sparsifier1.groups:
if mg["tensor_fqn"] == "linear1.weight":
mask1 = mg["module"].parametrizations.weight[0].mask
self.assertNotEqual(mask0, mask1)
sparsifier1.load_state_dict(state_dict)
# Make sure the states are loaded, and are correct
assert sparsifier0.state == sparsifier1.state
# Make sure the masks (and all dicts) are the same after loading
assert len(sparsifier0.groups) == len(sparsifier1.groups)
for idx in range(len(sparsifier0.groups)):
mg0 = sparsifier0.groups[idx]
mg1 = sparsifier1.groups[idx]
for key in mg0.keys():
assert key in mg1
if key == "module":
# We cannot compare modules as they are different
param0 = mg0[key].parametrizations.weight[0]
param1 = mg1[key].parametrizations.weight[0]
assert hasattr(param0, "mask")
assert hasattr(param1, "mask")
self.assertEqual(param0.__dict__, param1.__dict__)
else:
assert mg0[key] == mg1[key]
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_convert
|
def test_convert(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
new_model = sparsifier.convert(
model, mapping={nn.Linear: MockSparseLinear}, inplace=False
)
assert isinstance(new_model.linear1, MockSparseLinear)
assert isinstance(new_model.seq[0], nn.Linear)
assert isinstance(new_model.linear2, nn.Linear)
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_mask_squash
|
def test_mask_squash(self):
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
assert hasattr(model.linear.parametrizations.weight[0], 'mask')
assert is_parametrized(model.linear, 'weight')
assert not is_parametrized(model.seq[0], 'weight')
sparsifier.squash_mask()
assert not is_parametrized(model.seq[0], 'weight')
assert not is_parametrized(model.linear, 'weight')
|
def test_mask_squash(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
assert hasattr(model.linear1.parametrizations.weight[0], "mask")
assert is_parametrized(model.linear1, "weight")
assert not is_parametrized(model.seq[0], "weight")
sparsifier.squash_mask()
assert not is_parametrized(model.seq[0], "weight")
assert not is_parametrized(model.linear1, "weight")
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_mask_squash_with_params1
|
def test_mask_squash_with_params1(self):
model = Model()
sparsifier = ImplementedSparsifier(foo=3, bar=2, baz=1)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}, {'tensor_fqn': 'seq.0.weight'}])
sparsifier.squash_mask(
params_to_keep_per_layer={
'linear': ('foo', 'bar'),
'seq.0': ('baz',)
})
assert not is_parametrized(model.seq[0], 'weight')
assert not is_parametrized(model.linear, 'weight')
assert hasattr(model.seq[0], 'sparse_params')
assert hasattr(model.linear, 'sparse_params')
assert model.seq[0].sparse_params.get('foo', None) is None
assert model.seq[0].sparse_params.get('bar', None) is None
assert model.seq[0].sparse_params.get('baz', None) == 1
assert model.linear.sparse_params.get('foo', None) == 3
assert model.linear.sparse_params.get('bar', None) == 2
assert model.linear.sparse_params.get('baz', None) is None
|
def test_mask_squash_with_params1(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(foo=3, bar=2, baz=1)
sparsifier.prepare(
model, [{"tensor_fqn": "linear1.weight"}, {"tensor_fqn": "seq.0.weight"}]
)
sparsifier.squash_mask(
params_to_keep_per_layer={"linear1": ("foo", "bar"), "seq.0": ("baz",)}
)
assert not is_parametrized(model.seq[0], "weight")
assert not is_parametrized(model.linear1, "weight")
assert hasattr(model.seq[0], "sparse_params")
assert hasattr(model.linear1, "sparse_params")
assert model.seq[0].sparse_params.get("foo", None) is None
assert model.seq[0].sparse_params.get("bar", None) is None
assert model.seq[0].sparse_params.get("baz", None) == 1
assert model.linear1.sparse_params.get("foo", None) == 3
assert model.linear1.sparse_params.get("bar", None) == 2
assert model.linear1.sparse_params.get("baz", None) is None
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_mask_squash_with_params2
|
def test_mask_squash_with_params2(self):
model = Model()
sparsifier = ImplementedSparsifier(foo=3, bar=2, baz=1)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}, {'tensor_fqn': 'seq.0.weight'}])
sparsifier.squash_mask(params_to_keep=('foo', 'bar'))
assert not is_parametrized(model.seq[0], 'weight')
assert not is_parametrized(model.linear, 'weight')
assert hasattr(model.seq[0], 'sparse_params')
assert hasattr(model.linear, 'sparse_params')
assert model.seq[0].sparse_params.get('foo', None) == 3
assert model.seq[0].sparse_params.get('bar', None) == 2
assert model.seq[0].sparse_params.get('baz', None) is None
assert model.linear.sparse_params.get('foo', None) == 3
assert model.linear.sparse_params.get('bar', None) == 2
assert model.linear.sparse_params.get('baz', None) is None
|
def test_mask_squash_with_params2(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(foo=3, bar=2, baz=1)
sparsifier.prepare(
model, [{"tensor_fqn": "linear1.weight"}, {"tensor_fqn": "seq.0.weight"}]
)
sparsifier.squash_mask(params_to_keep=("foo", "bar"))
assert not is_parametrized(model.seq[0], "weight")
assert not is_parametrized(model.linear1, "weight")
assert hasattr(model.seq[0], "sparse_params")
assert hasattr(model.linear1, "sparse_params")
assert model.seq[0].sparse_params.get("foo", None) == 3
assert model.seq[0].sparse_params.get("bar", None) == 2
assert model.seq[0].sparse_params.get("baz", None) is None
assert model.linear1.sparse_params.get("foo", None) == 3
assert model.linear1.sparse_params.get("bar", None) == 2
assert model.linear1.sparse_params.get("baz", None) is None
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_mask_squash_with_params3
|
def test_mask_squash_with_params3(self):
model = Model()
sparsifier = ImplementedSparsifier(foo=3, bar=2, baz=1)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}, {'tensor_fqn': 'seq.0.weight'}])
sparsifier.squash_mask(
params_to_keep=('foo', 'bar'),
params_to_keep_per_layer={'seq.0': ('baz',)})
assert not is_parametrized(model.seq[0], 'weight')
assert not is_parametrized(model.linear, 'weight')
assert hasattr(model.seq[0], 'sparse_params')
assert hasattr(model.linear, 'sparse_params')
assert model.seq[0].sparse_params.get('foo', None) == 3
assert model.seq[0].sparse_params.get('bar', None) == 2
assert model.seq[0].sparse_params.get('baz', None) == 1
assert model.linear.sparse_params.get('foo', None) == 3
assert model.linear.sparse_params.get('bar', None) == 2
assert model.linear.sparse_params.get('baz', None) is None
|
def test_mask_squash_with_params3(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(foo=3, bar=2, baz=1)
sparsifier.prepare(
model, [{"tensor_fqn": "linear1.weight"}, {"tensor_fqn": "seq.0.weight"}]
)
sparsifier.squash_mask(
params_to_keep=("foo", "bar"), params_to_keep_per_layer={"seq.0": ("baz",)}
)
assert not is_parametrized(model.seq[0], "weight")
assert not is_parametrized(model.linear1, "weight")
assert hasattr(model.seq[0], "sparse_params")
assert hasattr(model.linear1, "sparse_params")
assert model.seq[0].sparse_params.get("foo", None) == 3
assert model.seq[0].sparse_params.get("bar", None) == 2
assert model.seq[0].sparse_params.get("baz", None) == 1
assert model.linear1.sparse_params.get("foo", None) == 3
assert model.linear1.sparse_params.get("bar", None) == 2
assert model.linear1.sparse_params.get("baz", None) is None
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_constructor
|
def test_constructor(self):
# Cannot instantiate the abstract base
self.assertRaises(TypeError, BaseSparsifier)
# Can instantiate the model with no configs
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, config=None)
assert len(sparsifier.groups) == 3
sparsifier.step()
# Can instantiate the model with configs
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
assert len(sparsifier.groups) == 1
assert sparsifier.groups[0]['tensor_fqn'] == 'linear.weight'
assert 'test' in sparsifier.groups[0]
assert sparsifier.groups[0]['test'] == 3
|
def test_constructor(self):
# Cannot instantiate the abstract base
self.assertRaises(TypeError, BaseSparsifier)
# Can instantiate the model with no configs
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, config=None)
assert len(sparsifier.groups) == 5
sparsifier.step()
# Can instantiate the model with configs
sparsifier = ImplementedSparsifier(test=3)
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
assert len(sparsifier.groups) == 1
assert sparsifier.groups[0]["tensor_fqn"] == "linear1.weight"
assert "test" in sparsifier.groups[0]
assert sparsifier.groups[0]["test"] == 3
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_sparsifier.py
|
test_step
|
def test_step(self):
model = Model()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.enable_mask_update = True
sparsifier.prepare(model, [{'tensor_fqn': 'linear.weight'}])
sparsifier.step()
assert torch.all(model.linear.parametrizations.weight[0].mask[0] == 0)
|
def test_step(self):
model = SimpleLinear()
sparsifier = ImplementedSparsifier(test=3)
sparsifier.enable_mask_update = True
sparsifier.prepare(model, [{"tensor_fqn": "linear1.weight"}])
sparsifier.step()
assert torch.all(model.linear1.parametrizations.weight[0].mask[0] == 0)
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import BaseSparsifier, WeightNormSparsifier, FakeSparsity, NearlyDiagonalSparsifier
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
import itertools
import logging
import re
import torch
from torch import nn
from torch.ao.pruning import (
BaseSparsifier,
FakeSparsity,
NearlyDiagonalSparsifier,
WeightNormSparsifier,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_pruning import (
ImplementedSparsifier,
MockSparseLinear,
SimpleLinear,
)
from torch.testing._internal.common_utils import TestCase
class TestBaseSparsifier(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
forward
|
def forward(self, x):
x = self.conv2d1(x)
x = self.conv2d2(x)
return x
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class SimpleConvFPGM(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
test_compute_distance
|
def test_compute_distance(self, device="cpu"):
"""Test the distance computation function"""
model = TestFPGMPruner.SimpleConvFPGM().to(device)
pruner = FPGMPruner(0.3)
dist_conv1 = pruner._compute_distance(model.conv2d1.weight)
# compute the distance matrix using torch.cdist
flattened_filters = torch.Tensor(
[
[
3.0000,
3.0000,
3.0000,
3.0000,
3.0000,
3.0000,
3.0000,
3.0000,
3.0000,
],
[
2.0000,
2.0000,
2.0000,
2.0000,
2.0000,
2.0000,
2.0000,
2.0000,
2.0000,
],
[
0.1000,
0.1000,
0.1000,
0.1000,
0.1000,
0.1000,
0.1000,
0.1000,
0.1000,
],
]
)
"""
Expected distance matrix should have the following values:
[0.0000, 3.0000, 8.7000],
[3.0000, 0.0000, 5.7000],
[8.7000, 5.7000, 0.0000],
the distance should therefore be:
[11.7000, 8.7000, 14.4000]
"""
expected_dist_matrix_conv1 = torch.cdist(
flattened_filters, flattened_filters, p=2
)
expected_dist_conv1 = torch.sum(torch.abs(expected_dist_matrix_conv1), 1)
assert torch.isclose(
dist_conv1, expected_dist_conv1, rtol=1e-05, atol=1e-07
).all()
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestFPGMPruner(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
_test_update_mask_on_single_layer
|
def _test_update_mask_on_single_layer(self, expected_conv1, device):
"""Test that pruning is conducted based on the pair-wise distance measurement instead of absolute norm value"""
# test pruning with one layer of conv2d
model = TestFPGMPruner.SimpleConvFPGM().to(device)
x = torch.ones((1, 1, 32, 32), device=device)
pruner = FPGMPruner(0.3)
config = [{"tensor_fqn": "conv2d1.weight"}]
pruner.prepare(model, config)
pruner.enable_mask_update = True
pruner.step()
assert (
pruner.groups[0]["module"].parametrizations.weight[0].mask[-1].item()
is not False
), "do not prune the least-norm filter"
# fusion step
pruned_model = pruner.prune()
pruned_y = pruned_model(x)
# assert shapes
expected_conv1 = expected_conv1.to(device)
assert pruned_y.shape == (1, 4, 32, 32)
assert pruned_model.conv2d1.weight.shape == expected_conv1.shape
assert pruned_model.conv2d2.weight.shape == (
4,
2,
3,
3,
), "conv2d2 should have input channel pruned"
# assert value
assert torch.isclose(
pruned_model.conv2d1.weight, expected_conv1, rtol=1e-05, atol=1e-07
).all()
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestFPGMPruner(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/ao/sparsity/test_structured_sparsifier.py
|
test_update_mask
|
def test_update_mask(self):
weights = torch.tensor([3.0, 0.1])
expected_conv1 = torch.ones((2, 1, 3, 3)) * weights[:, None, None, None]
weights = torch.tensor([7.0, 0.4])
expected_conv2 = torch.ones((2, 2, 3, 3)) * weights[:, None, None, None]
for device in DEVICES:
self._test_update_mask_on_single_layer(expected_conv1, device)
self._test_update_mask_on_multiple_layer(
expected_conv1, expected_conv2, device
)
|
import copy
import logging
import random
import torch
from torch import nn
from torch.ao.pruning._experimental.pruner import (
BaseStructuredSparsifier,
FakeStructuredSparsity,
FPGMPruner,
LSTMSaliencyPruner,
SaliencyPruner,
)
from torch.nn.utils import parametrize
from torch.testing._internal.common_pruning import (
Conv2dActivation,
Conv2dBias,
Conv2dPadBias,
Conv2dPool,
Conv2dPoolFlatten,
Conv2dPoolFlattenFunctional,
LinearActivation,
LinearActivationFunctional,
LinearBias,
LSTMLayerNormLinearModel,
LSTMLinearModel,
rows_are_subset,
SimpleConv2d,
SimpleLinear,
)
from torch.testing._internal.common_utils import skipIfTorchDynamo, TestCase
DEVICES = {
torch.device("cpu"),
torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"),
}
class TestFPGMPruner(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/autograd/test_complex.py
|
test_view_func_for_complex_views
|
def test_view_func_for_complex_views(self):
# case 1: both parent and child have view_func
x = torch.randn(2, 2, 2, dtype=torch.double, requires_grad=True)
y = x.detach().requires_grad_(True)
x0 = x.clone()
x1 = torch.view_as_complex(x0)
x2 = torch.view_as_real(x1)
x2.mul_(2)
x2.sum().backward()
y0 = y.clone()
y0.mul_(2)
y0.sum().backward()
self.assertEqual(x.grad, y.grad)
# case 2: parent has view_func but child does not
x = torch.randn(2, 2, 2, dtype=torch.double, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a):
b = a.clone()
b1 = torch.view_as_complex(b)
b2 = b1.reshape(b1.numel())
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().backward()
self.assertEqual(x.grad, y.grad)
# case 3: parent does not have a view_func but child does
x = torch.randn(10, dtype=torch.cdouble, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a, dim0_size=5):
b = a.clone()
b1 = b.reshape(dim0_size, 2)
b2 = torch.view_as_real(b1)
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().backward()
self.assertEqual(x.grad, y.grad)
|
def test_view_func_for_complex_views(self):
# case 1: both parent and child have view_func
x = torch.randn(2, 2, 2, dtype=torch.double, requires_grad=True)
y = x.detach().requires_grad_(True)
x0 = x.clone()
x1 = torch.view_as_complex(x0)
x2 = torch.view_as_real(x1)
x2.mul_(2)
x2.sum().abs().backward()
y0 = y.clone()
y0.mul_(2)
y0.sum().abs().backward()
self.assertEqual(x.grad, y.grad)
# case 2: parent has view_func but child does not
x = torch.randn(2, 2, 2, dtype=torch.double, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a):
b = a.clone()
b1 = torch.view_as_complex(b)
b2 = b1.reshape(b1.numel())
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().abs().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().abs().backward()
self.assertEqual(x.grad, y.grad)
# case 3: parent does not have a view_func but child does
x = torch.randn(10, dtype=torch.cdouble, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a, dim0_size=5):
b = a.clone()
b1 = b.reshape(dim0_size, 2)
b2 = torch.view_as_real(b1)
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().abs().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().abs().backward()
self.assertEqual(x.grad, y.grad)
|
import torch
from torch.testing._internal.common_utils import TestCase, run_tests, gradcheck
class TestAutogradComplex(TestCase):
|
import torch
from torch.testing._internal.common_utils import gradcheck, run_tests, TestCase
class TestAutogradComplex(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/autograd/test_complex.py
|
fn
|
def fn(a):
b = a.clone()
b1 = torch.view_as_complex(b)
b2 = b1.reshape(b1.numel())
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().backward()
self.assertEqual(x.grad, y.grad)
# case 3: parent does not have a view_func but child does
x = torch.randn(10, dtype=torch.cdouble, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a, dim0_size=5):
b = a.clone()
b1 = b.reshape(dim0_size, 2)
b2 = torch.view_as_real(b1)
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().backward()
self.assertEqual(x.grad, y.grad)
|
def fn(a):
b = a.clone()
b1 = torch.view_as_complex(b)
b2 = b1.reshape(b1.numel())
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().abs().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().abs().backward()
self.assertEqual(x.grad, y.grad)
# case 3: parent does not have a view_func but child does
x = torch.randn(10, dtype=torch.cdouble, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a, dim0_size=5):
b = a.clone()
b1 = b.reshape(dim0_size, 2)
b2 = torch.view_as_real(b1)
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().abs().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().abs().backward()
self.assertEqual(x.grad, y.grad)
|
import torch
from torch.testing._internal.common_utils import TestCase, run_tests, gradcheck
|
import torch
from torch.testing._internal.common_utils import gradcheck, run_tests, TestCase
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/autograd/test_complex.py
|
fn
|
def fn(a):
b = a.clone()
b1 = torch.view_as_complex(b)
b2 = b1.reshape(b1.numel())
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().backward()
self.assertEqual(x.grad, y.grad)
# case 3: parent does not have a view_func but child does
x = torch.randn(10, dtype=torch.cdouble, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a, dim0_size=5):
b = a.clone()
b1 = b.reshape(dim0_size, 2)
b2 = torch.view_as_real(b1)
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().backward()
self.assertEqual(x.grad, y.grad)
|
def fn(a):
b = a.clone()
b1 = torch.view_as_complex(b)
b2 = b1.reshape(b1.numel())
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().abs().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().abs().backward()
self.assertEqual(x.grad, y.grad)
# case 3: parent does not have a view_func but child does
x = torch.randn(10, dtype=torch.cdouble, requires_grad=True)
y = x.detach().requires_grad_(True)
def fn(a, dim0_size=5):
b = a.clone()
b1 = b.reshape(dim0_size, 2)
b2 = torch.view_as_real(b1)
return b2
x0 = fn(x)
x0.mul_(2)
x0.sum().abs().backward()
y0 = fn(y)
y1 = y0.mul(2)
y1.sum().abs().backward()
self.assertEqual(x.grad, y.grad)
|
import torch
from torch.testing._internal.common_utils import TestCase, run_tests, gradcheck
|
import torch
from torch.testing._internal.common_utils import gradcheck, run_tests, TestCase
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/ao/sparsity/test_data_sparsifier.py
|
test_ptq_quantize_first
|
def test_ptq_quantize_first(self):
"""The expectation is post_training_sparse_quantize function
1. Takes in a model
2. Quantize the embeddings
3. Sparsifies the embeddings
This unit test checks that
1. Embeddings and EmbeddingBags are sparsified to the right sparsity levels
2. Embeddings and EmbeddingBags are quantized
3. Linear modules are not quanitzed
"""
model = Model()
sparse_config = {'sparsity_level': 0.8, 'sparse_block_shape': (1, 1)}
post_training_sparse_quantize(model, DataNormSparsifier, sparsify_first=False, **sparse_config)
assert type(model.emb1) == torch.ao.nn.quantized.modules.embedding_ops.Embedding
assert type(model.embbag1) == torch.ao.nn.quantized.modules.embedding_ops.EmbeddingBag
assert type(model.emb_seq[0] == torch.ao.nn.quantized.modules.embedding_ops.Embedding)
assert type(model.emb_seq[1] == torch.ao.nn.quantized.modules.embedding_ops.EmbeddingBag)
assert type(model.linear1) == nn.Linear # not quantized
assert type(model.linear2) == nn.Linear # not quantized
dequant_emb1 = torch.dequantize(model.emb1.weight())
dequant_embbag1 = torch.dequantize(model.embbag1.weight())
dequant_emb_seq_0 = torch.dequantize(model.emb_seq[0].weight())
dequant_emb_seq_1 = torch.dequantize(model.emb_seq[1].weight())
# higher threshold as quantization occurs before sparsity
threshold = 1 # zero points seem to have higher magnitude with sparsity occuring after
sl_emb1 = (torch.abs(dequant_emb1) < threshold).float().mean()
sl_embbag1 = (torch.abs(dequant_embbag1) < threshold).float().mean()
sl_emb_seq_0 = (torch.abs(dequant_emb_seq_0) < threshold).float().mean()
sl_emb_seq_1 = (torch.abs(dequant_emb_seq_1) < threshold).float().mean()
assert abs(sl_emb1 - 0.80) <= 0.05 # +- 5% leeway
assert abs(sl_embbag1 - 0.80) <= 0.05 # +- 5% leeway
assert abs(sl_emb_seq_0 - 0.80) <= 0.05 # +- 5% leeway
assert abs(sl_emb_seq_1 - 0.80) <= 0.05 # +- 5% leeway
|
def test_ptq_quantize_first(self):
"""The expectation is post_training_sparse_quantize function
1. Takes in a model
2. Quantize the embeddings
3. Sparsifies the embeddings
This unit test checks that
1. Embeddings and EmbeddingBags are sparsified to the right sparsity levels
2. Embeddings and EmbeddingBags are quantized
3. Linear modules are not quantized
"""
model = Model()
sparse_config = {"sparsity_level": 0.8, "sparse_block_shape": (1, 1)}
post_training_sparse_quantize(
model, DataNormSparsifier, sparsify_first=False, **sparse_config
)
assert type(model.emb1) == torch.ao.nn.quantized.modules.embedding_ops.Embedding
assert (
type(model.embbag1)
== torch.ao.nn.quantized.modules.embedding_ops.EmbeddingBag
)
assert type(
model.emb_seq[0] == torch.ao.nn.quantized.modules.embedding_ops.Embedding
)
assert type(
model.emb_seq[1] == torch.ao.nn.quantized.modules.embedding_ops.EmbeddingBag
)
assert type(model.linear1) == nn.Linear # not quantized
assert type(model.linear2) == nn.Linear # not quantized
dequant_emb1 = torch.dequantize(model.emb1.weight())
dequant_embbag1 = torch.dequantize(model.embbag1.weight())
dequant_emb_seq_0 = torch.dequantize(model.emb_seq[0].weight())
dequant_emb_seq_1 = torch.dequantize(model.emb_seq[1].weight())
# higher threshold as quantization occurs before sparsity
threshold = (
1 # zero points seem to have higher magnitude with sparsity occuring after
)
sl_emb1 = (torch.abs(dequant_emb1) < threshold).float().mean()
sl_embbag1 = (torch.abs(dequant_embbag1) < threshold).float().mean()
sl_emb_seq_0 = (torch.abs(dequant_emb_seq_0) < threshold).float().mean()
sl_emb_seq_1 = (torch.abs(dequant_emb_seq_1) < threshold).float().mean()
assert abs(sl_emb1 - 0.80) <= 0.05 # +- 5% leeway
assert abs(sl_embbag1 - 0.80) <= 0.05 # +- 5% leeway
assert abs(sl_emb_seq_0 - 0.80) <= 0.05 # +- 5% leeway
assert abs(sl_emb_seq_1 - 0.80) <= 0.05 # +- 5% leeway
|
import logging
import torch
from torch.nn.utils.parametrize import is_parametrized
import unittest
from torch.testing._internal.common_utils import TestCase, TEST_WITH_ASAN
from typing import Tuple
from torch import nn
import itertools
import math
import copy
from torch.ao.pruning._experimental.data_sparsifier import BaseDataSparsifier, DataNormSparsifier
from torch.ao.pruning._experimental.data_sparsifier.quantization_utils import post_training_sparse_quantize
class TestQuantizationUtils(TestCase):
|
import copy
import itertools
import logging
import math
from typing import Tuple
import torch
from torch import nn
from torch.ao.pruning._experimental.data_sparsifier import (
BaseDataSparsifier,
DataNormSparsifier,
)
from torch.ao.pruning._experimental.data_sparsifier.quantization_utils import (
post_training_sparse_quantize,
)
from torch.nn.utils.parametrize import is_parametrized
from torch.testing._internal.common_utils import TestCase
class TestQuantizationUtils(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/aoti_inference/test.py
|
forward
|
def forward(self, x):
w_transpose = torch.transpose(self.w_pre, 0, 1)
w_relu = torch.nn.functional.relu(w_transpose)
w = w_relu + self.w_add
return torch.matmul(x, w)
|
import torch
from torch._export import aot_compile
from torch.export import Dim
class Net(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/test.py
|
forward
|
def forward(self, x):
w_transpose = torch.transpose(self.w_pre, 0, 1)
w_relu = torch.nn.functional.relu(w_transpose)
w = w_relu + self.w_add
return torch.matmul(x, w)
|
import torch
from torch._export import aot_compile
from torch.export import Dim
class Net(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/test.py
|
generate_basic_tests
|
def generate_basic_tests():
for device in ["cpu", "cuda"] if torch.cuda.is_available() else ["cpu"]:
for use_runtime_constant_folding in [True, False]:
if device == "cpu" and use_runtime_constant_folding:
# We do not test runtime const folding for cpu mode.
continue
model = Net(device).to(device=device)
x = torch.randn((4, 4), device=device)
with torch.no_grad():
ref_output = model(x)
torch._dynamo.reset()
with torch.no_grad():
dim0_x = Dim("dim0_x", min=1, max=1024)
dynamic_shapes = {"x": {0: dim0_x}}
model_so_path = aot_compile(
model,
(x,),
dynamic_shapes=dynamic_shapes,
options={
"aot_inductor.use_runtime_constant_folding": use_runtime_constant_folding
},
)
suffix = f"{device}"
if use_runtime_constant_folding:
suffix += "_use_runtime_constant_folding"
data.update(
{
f"model_so_path_{suffix}": model_so_path,
f"inputs_{suffix}": [x],
f"outputs_{suffix}": [ref_output],
f"w_pre_{suffix}": model.w_pre,
f"w_add_{suffix}": model.w_add,
}
)
# AOTI model which will create additional tensors during autograd.
|
import torch
from torch._export import aot_compile
from torch.export import Dim
data = {}
data_with_tensor_constants = {}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/test.py
|
generate_test_with_additional_tensors
|
def generate_test_with_additional_tensors():
if not torch.cuda.is_available():
return
model = NetWithTensorConstants()
x = torch.randn((30, 1), device="cuda")
y = torch.randn((30, 1), device="cuda")
with torch.no_grad():
ref_output = model(x, y)
torch._dynamo.reset()
with torch.no_grad():
model_so_path = aot_compile(model, (x, y))
data_with_tensor_constants.update(
{
"model_so_path": model_so_path,
"inputs": [x, y],
"outputs": [ref_output],
"w": model.w,
}
)
generate_basic_tests()
generate_test_with_additional_tensors()
# Use this to communicate tensors to the cpp code
class Serializer(torch.nn.Module):
def __init__(self, data):
super().__init__()
for key in data:
setattr(self, key, data[key])
torch.jit.script(Serializer(data)).save("data.pt")
torch.jit.script(Serializer(data_with_tensor_constants)).save(
"data_with_tensor_constants.pt"
)
|
import torch
from torch._export import aot_compile
from torch.export import Dim
data = {}
data_with_tensor_constants = {}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/test.py
|
__init__
|
def __init__(self, device):
super().__init__()
self.w_pre = torch.randn(4, 4, device=device)
self.w_add = torch.randn(4, 4, device=device)
|
import torch
from torch._export import aot_compile
from torch.export import Dim
class Net(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/api/init_baseline.py
|
emit
|
def emit(initializer_parameter_map):
# Don't write generated with an @ in front, else this file is recognized as generated.
print("// @{} from {}".format('generated', __file__))
print(HEADER)
for initializer_name, weights in initializer_parameter_map.items():
print(PARAMETERS.format(initializer_name))
print(" return {")
for sample in weights:
print(" {")
for parameter in sample:
parameter_values = "{{{}}}".format(", ".join(map(str, parameter)))
print(" torch::tensor({}),".format(parameter_values))
print(" },")
print(" };")
print("}\n")
print(FOOTER)
|
def emit(initializer_parameter_map):
# Don't write generated with an @ in front, else this file is recognized as generated.
print("// @{} from {}".format("generated", __file__))
print(HEADER)
for initializer_name, weights in initializer_parameter_map.items():
print(PARAMETERS.format(initializer_name))
print(" return {")
for sample in weights:
print(" {")
for parameter in sample:
parameter_values = "{{{}}}".format(", ".join(map(str, parameter)))
print(f" torch::tensor({parameter_values}),")
print(" },")
print(" };")
print("}\n")
print(FOOTER)
|
import sys
import torch
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
INITIALIZERS = {
"Xavier_Uniform": lambda w: torch.nn.init.xavier_uniform(w),
"Xavier_Normal": lambda w: torch.nn.init.xavier_normal(w),
"Kaiming_Normal": lambda w: torch.nn.init.kaiming_normal(w),
"Kaiming_Uniform": lambda w: torch.nn.init.kaiming_uniform(w)
}
|
import sys
import torch
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
INITIALIZERS = {
"Xavier_Uniform": lambda w: torch.nn.init.xavier_uniform(w),
"Xavier_Normal": lambda w: torch.nn.init.xavier_normal(w),
"Kaiming_Normal": lambda w: torch.nn.init.kaiming_normal(w),
"Kaiming_Uniform": lambda w: torch.nn.init.kaiming_uniform(w),
}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/api/init_baseline.py
|
main
|
def main():
initializer_parameter_map = {}
for initializer in INITIALIZERS.keys():
sys.stderr.write('Evaluating {} ...\n'.format(initializer))
initializer_parameter_map[initializer] = run(initializer)
emit(initializer_parameter_map)
if __name__ == "__main__":
main()
|
def main():
initializer_parameter_map = {}
for initializer in INITIALIZERS.keys():
sys.stderr.write(f"Evaluating {initializer} ...\n")
initializer_parameter_map[initializer] = run(initializer)
emit(initializer_parameter_map)
if __name__ == "__main__":
main()
|
import sys
import torch
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
INITIALIZERS = {
"Xavier_Uniform": lambda w: torch.nn.init.xavier_uniform(w),
"Xavier_Normal": lambda w: torch.nn.init.xavier_normal(w),
"Kaiming_Normal": lambda w: torch.nn.init.kaiming_normal(w),
"Kaiming_Uniform": lambda w: torch.nn.init.kaiming_uniform(w)
}
|
import sys
import torch
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
INITIALIZERS = {
"Xavier_Uniform": lambda w: torch.nn.init.xavier_uniform(w),
"Xavier_Normal": lambda w: torch.nn.init.xavier_normal(w),
"Kaiming_Normal": lambda w: torch.nn.init.kaiming_normal(w),
"Kaiming_Uniform": lambda w: torch.nn.init.kaiming_uniform(w),
}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/jit/tests_setup.py
|
shutdown
|
def shutdown(self):
raise NotImplementedError()
|
def shutdown(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp_api_parity/functional_impl_check.py
|
test_forward
|
def test_forward(unit_test_class, test_params):
functional_variant_name = test_params.functional_variant_name
cpp_tmp_folder = test_params.cpp_tmp_folder
# Remove the temporary folder if it exists already
try_remove_folder(cpp_tmp_folder)
os.mkdir(cpp_tmp_folder)
# Run forward on Python functional
python_output = run_forward(unit_test_class, test_params)
# Save Python arguments to be used from C++ function
arg_dict_file_path = compute_temp_file_path(cpp_tmp_folder, functional_variant_name, 'arg_dict')
serialize_arg_dict_as_script_module(test_params.arg_dict).save(arg_dict_file_path)
cpp_test_name = '{}_test_forward'.format(test_params.functional_variant_name)
cpp_test_fn = getattr(unit_test_class.functional_impl_check_cpp_module, cpp_test_name)
def run_cpp_test_fn_and_check_output():
forward_output_file_path = compute_temp_file_path(cpp_tmp_folder, functional_variant_name, 'forward_output')
cpp_test_fn(arg_dict_file_path, forward_output_file_path)
cpp_output = torch.load(forward_output_file_path)
# Check that forward outputs are equal
unit_test_class.assertEqual(
python_output, cpp_output,
msg=generate_error_msg("forward output", cpp_output, python_output))
run_cpp_test_fn_and_check_output()
# Remove temporary folder that stores C++ outputs
try_remove_folder(cpp_tmp_folder)
|
def test_forward(unit_test_class, test_params):
functional_variant_name = test_params.functional_variant_name
cpp_tmp_folder = test_params.cpp_tmp_folder
# Remove the temporary folder if it exists already
try_remove_folder(cpp_tmp_folder)
os.mkdir(cpp_tmp_folder)
# Run forward on Python functional
python_output = run_forward(unit_test_class, test_params)
# Save Python arguments to be used from C++ function
arg_dict_file_path = compute_temp_file_path(
cpp_tmp_folder, functional_variant_name, "arg_dict"
)
serialize_arg_dict_as_script_module(test_params.arg_dict).save(arg_dict_file_path)
cpp_test_name = f"{test_params.functional_variant_name}_test_forward"
cpp_test_fn = getattr(
unit_test_class.functional_impl_check_cpp_module, cpp_test_name
)
def run_cpp_test_fn_and_check_output():
forward_output_file_path = compute_temp_file_path(
cpp_tmp_folder, functional_variant_name, "forward_output"
)
cpp_test_fn(arg_dict_file_path, forward_output_file_path)
cpp_output = torch.load(forward_output_file_path)
# Check that forward outputs are equal
unit_test_class.assertEqual(
python_output,
cpp_output,
msg=generate_error_msg("forward output", cpp_output, python_output),
)
run_cpp_test_fn_and_check_output()
# Remove temporary folder that stores C++ outputs
try_remove_folder(cpp_tmp_folder)
|
import tempfile
from string import Template
import re
import pprint
import os
import torch
from cpp_api_parity.utils import TorchNNFunctionalTestParams, TORCH_NN_COMMON_TEST_HARNESS, \
compile_cpp_code_inline, set_python_tensors_requires_grad, move_python_tensors_to_device, \
add_test, compute_cpp_args_construction_stmts_and_forward_arg_symbols, serialize_arg_dict_as_script_module, \
compute_arg_dict, decorate_test_fn, compute_temp_file_path, generate_error_msg, is_torch_nn_functional_test, \
try_remove_folder
from cpp_api_parity.sample_functional import SAMPLE_FUNCTIONAL_CPP_SOURCE
TORCH_NN_FUNCTIONAL_TEST_FORWARD = Template("""
void ${functional_variant_name}_test_forward(
const std::string& arg_dict_file_path,
const std::string& forward_output_file_path) {
pybind11::gil_scoped_release no_gil;
namespace F = torch::nn::functional;
// Declare arguments
auto arg_dict = load_dict_from_file(arg_dict_file_path);
${cpp_args_construction_stmts};
// Some functionals (such as `F::rrelu`) create random tensors in their call path.
// To make sure the random tensors created are the same in Python/C++, we need
// to set the RNG seed manually.
torch::manual_seed(0);
// Run function with arguments
auto cpp_output = ${cpp_function_call};
// Save the output into a file to be compared in Python later
write_ivalue_to_file(torch::IValue(cpp_output), forward_output_file_path);
}
""")
|
import os
import pprint
import re
import tempfile
from string import Template
import torch
from cpp_api_parity.sample_functional import SAMPLE_FUNCTIONAL_CPP_SOURCE
from cpp_api_parity.utils import (
add_test,
compile_cpp_code_inline,
compute_arg_dict,
compute_cpp_args_construction_stmts_and_forward_arg_symbols,
compute_temp_file_path,
decorate_test_fn,
generate_error_msg,
is_torch_nn_functional_test,
move_python_tensors_to_device,
serialize_arg_dict_as_script_module,
set_python_tensors_requires_grad,
TORCH_NN_COMMON_TEST_HARNESS,
TorchNNFunctionalTestParams,
try_remove_folder,
)
TORCH_NN_FUNCTIONAL_TEST_FORWARD = Template(
"""
void ${functional_variant_name}_test_forward(
const std::string& arg_dict_file_path,
const std::string& forward_output_file_path) {
pybind11::gil_scoped_release no_gil;
namespace F = torch::nn::functional;
// Declare arguments
auto arg_dict = load_dict_from_file(arg_dict_file_path);
${cpp_args_construction_stmts};
// Some functionals (such as `F::rrelu`) create random tensors in their call path.
// To make sure the random tensors created are the same in Python/C++, we need
// to set the RNG seed manually.
torch::manual_seed(0);
// Run function with arguments
auto cpp_output = ${cpp_function_call};
// Save the output into a file to be compared in Python later
write_ivalue_to_file(torch::IValue(cpp_output), forward_output_file_path);
}
"""
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp_api_parity/functional_impl_check.py
|
camel_case_to_snake_case
|
def camel_case_to_snake_case(camel_case_str):
return re.sub(r'(?<!^)(?=[A-Z])', '_', camel_case_str).lower()
if 'cpp_options_args' in test_params_dict:
# Expected format for `cpp_options_args`: `F::FunctionalFuncOptions(...)`
# Example output: `binary_cross_entropy`
return camel_case_to_snake_case(
test_params_dict['cpp_options_args'].split('(')[0].replace('F::', '').replace('FuncOptions', ''))
elif 'cpp_function_call' in test_params_dict:
# Expected format for `cpp_function_call`: `F::functional_name(...)`
# Example output: `binary_cross_entropy`
return test_params_dict['cpp_function_call'].split('(')[0].replace('F::', '')
else:
raise RuntimeError(
"`cpp_options_args` or `cpp_function_call` entry must be present in test params dict:\n{}".format(
pprint.pformat(test_params_dict)))
|
def camel_case_to_snake_case(camel_case_str):
return re.sub(r"(?<!^)(?=[A-Z])", "_", camel_case_str).lower()
if "cpp_options_args" in test_params_dict:
# Expected format for `cpp_options_args`: `F::FunctionalFuncOptions(...)`
# Example output: `binary_cross_entropy`
return camel_case_to_snake_case(
test_params_dict["cpp_options_args"]
.split("(")[0]
.replace("F::", "")
.replace("FuncOptions", "")
)
elif "cpp_function_call" in test_params_dict:
# Expected format for `cpp_function_call`: `F::functional_name(...)`
# Example output: `binary_cross_entropy`
return test_params_dict["cpp_function_call"].split("(")[0].replace("F::", "")
else:
raise RuntimeError(
f"`cpp_options_args` or `cpp_function_call` entry must be present in test params dict:\n{pprint.pformat(test_params_dict)}" # noqa: B950
)
|
import tempfile
from string import Template
import re
import pprint
import os
import torch
from cpp_api_parity.utils import TorchNNFunctionalTestParams, TORCH_NN_COMMON_TEST_HARNESS, \
compile_cpp_code_inline, set_python_tensors_requires_grad, move_python_tensors_to_device, \
add_test, compute_cpp_args_construction_stmts_and_forward_arg_symbols, serialize_arg_dict_as_script_module, \
compute_arg_dict, decorate_test_fn, compute_temp_file_path, generate_error_msg, is_torch_nn_functional_test, \
try_remove_folder
from cpp_api_parity.sample_functional import SAMPLE_FUNCTIONAL_CPP_SOURCE
TORCH_NN_FUNCTIONAL_TEST_FORWARD = Template("""
void ${functional_variant_name}_test_forward(
const std::string& arg_dict_file_path,
const std::string& forward_output_file_path) {
pybind11::gil_scoped_release no_gil;
namespace F = torch::nn::functional;
// Declare arguments
auto arg_dict = load_dict_from_file(arg_dict_file_path);
${cpp_args_construction_stmts};
// Some functionals (such as `F::rrelu`) create random tensors in their call path.
// To make sure the random tensors created are the same in Python/C++, we need
// to set the RNG seed manually.
torch::manual_seed(0);
// Run function with arguments
auto cpp_output = ${cpp_function_call};
// Save the output into a file to be compared in Python later
write_ivalue_to_file(torch::IValue(cpp_output), forward_output_file_path);
}
""")
|
import os
import pprint
import re
import tempfile
from string import Template
import torch
from cpp_api_parity.sample_functional import SAMPLE_FUNCTIONAL_CPP_SOURCE
from cpp_api_parity.utils import (
add_test,
compile_cpp_code_inline,
compute_arg_dict,
compute_cpp_args_construction_stmts_and_forward_arg_symbols,
compute_temp_file_path,
decorate_test_fn,
generate_error_msg,
is_torch_nn_functional_test,
move_python_tensors_to_device,
serialize_arg_dict_as_script_module,
set_python_tensors_requires_grad,
TORCH_NN_COMMON_TEST_HARNESS,
TorchNNFunctionalTestParams,
try_remove_folder,
)
TORCH_NN_FUNCTIONAL_TEST_FORWARD = Template(
"""
void ${functional_variant_name}_test_forward(
const std::string& arg_dict_file_path,
const std::string& forward_output_file_path) {
pybind11::gil_scoped_release no_gil;
namespace F = torch::nn::functional;
// Declare arguments
auto arg_dict = load_dict_from_file(arg_dict_file_path);
${cpp_args_construction_stmts};
// Some functionals (such as `F::rrelu`) create random tensors in their call path.
// To make sure the random tensors created are the same in Python/C++, we need
// to set the RNG seed manually.
torch::manual_seed(0);
// Run function with arguments
auto cpp_output = ${cpp_function_call};
// Save the output into a file to be compared in Python later
write_ivalue_to_file(torch::IValue(cpp_output), forward_output_file_path);
}
"""
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp_api_parity/functional_impl_check.py
|
compute_cpp_function_call
|
def compute_cpp_function_call(test_params_dict, arg_dict, functional_name):
if 'cpp_function_call' in test_params_dict:
return test_params_dict['cpp_function_call']
elif 'cpp_options_args' in test_params_dict:
cpp_forward_args_symbols = [arg_name for arg_name, _ in
arg_dict['input'] + arg_dict['target'] + arg_dict['extra_args']]
return 'F::{}({}, {})'.format(
functional_name, ", ".join(cpp_forward_args_symbols), test_params_dict['cpp_options_args'])
else:
raise RuntimeError(
"`cpp_options_args` or `cpp_function_call` entry must be present in test params dict:\n{}".format(
pprint.pformat(test_params_dict)))
|
def compute_cpp_function_call(test_params_dict, arg_dict, functional_name):
if "cpp_function_call" in test_params_dict:
return test_params_dict["cpp_function_call"]
elif "cpp_options_args" in test_params_dict:
cpp_forward_args_symbols = [
arg_name
for arg_name, _ in arg_dict["input"]
+ arg_dict["target"]
+ arg_dict["extra_args"]
]
return "F::{}({}, {})".format(
functional_name,
", ".join(cpp_forward_args_symbols),
test_params_dict["cpp_options_args"],
)
else:
raise RuntimeError(
f"`cpp_options_args` or `cpp_function_call` entry must be present in test params dict:\n{pprint.pformat(test_params_dict)}" # noqa: B950
)
|
import tempfile
from string import Template
import re
import pprint
import os
import torch
from cpp_api_parity.utils import TorchNNFunctionalTestParams, TORCH_NN_COMMON_TEST_HARNESS, \
compile_cpp_code_inline, set_python_tensors_requires_grad, move_python_tensors_to_device, \
add_test, compute_cpp_args_construction_stmts_and_forward_arg_symbols, serialize_arg_dict_as_script_module, \
compute_arg_dict, decorate_test_fn, compute_temp_file_path, generate_error_msg, is_torch_nn_functional_test, \
try_remove_folder
from cpp_api_parity.sample_functional import SAMPLE_FUNCTIONAL_CPP_SOURCE
TORCH_NN_FUNCTIONAL_TEST_FORWARD = Template("""
void ${functional_variant_name}_test_forward(
const std::string& arg_dict_file_path,
const std::string& forward_output_file_path) {
pybind11::gil_scoped_release no_gil;
namespace F = torch::nn::functional;
// Declare arguments
auto arg_dict = load_dict_from_file(arg_dict_file_path);
${cpp_args_construction_stmts};
// Some functionals (such as `F::rrelu`) create random tensors in their call path.
// To make sure the random tensors created are the same in Python/C++, we need
// to set the RNG seed manually.
torch::manual_seed(0);
// Run function with arguments
auto cpp_output = ${cpp_function_call};
// Save the output into a file to be compared in Python later
write_ivalue_to_file(torch::IValue(cpp_output), forward_output_file_path);
}
""")
|
import os
import pprint
import re
import tempfile
from string import Template
import torch
from cpp_api_parity.sample_functional import SAMPLE_FUNCTIONAL_CPP_SOURCE
from cpp_api_parity.utils import (
add_test,
compile_cpp_code_inline,
compute_arg_dict,
compute_cpp_args_construction_stmts_and_forward_arg_symbols,
compute_temp_file_path,
decorate_test_fn,
generate_error_msg,
is_torch_nn_functional_test,
move_python_tensors_to_device,
serialize_arg_dict_as_script_module,
set_python_tensors_requires_grad,
TORCH_NN_COMMON_TEST_HARNESS,
TorchNNFunctionalTestParams,
try_remove_folder,
)
TORCH_NN_FUNCTIONAL_TEST_FORWARD = Template(
"""
void ${functional_variant_name}_test_forward(
const std::string& arg_dict_file_path,
const std::string& forward_output_file_path) {
pybind11::gil_scoped_release no_gil;
namespace F = torch::nn::functional;
// Declare arguments
auto arg_dict = load_dict_from_file(arg_dict_file_path);
${cpp_args_construction_stmts};
// Some functionals (such as `F::rrelu`) create random tensors in their call path.
// To make sure the random tensors created are the same in Python/C++, we need
// to set the RNG seed manually.
torch::manual_seed(0);
// Run function with arguments
auto cpp_output = ${cpp_function_call};
// Save the output into a file to be compared in Python later
write_ivalue_to_file(torch::IValue(cpp_output), forward_output_file_path);
}
"""
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/api/optim_baseline.py
|
emit
|
def emit(optimizer_parameter_map):
# Don't write generated with an @ in front, else this file is recognized as generated.
print("// @{} from {}".format('generated', __file__))
print(HEADER)
for optimizer_name, parameters in optimizer_parameter_map.items():
print(PARAMETERS.format(optimizer_name))
print(" return {")
for sample in parameters:
print(" {")
for parameter in sample:
parameter_values = "{{{}}}".format(", ".join(map(str, parameter)))
print(" torch::tensor({}),".format(parameter_values))
print(" },")
print(" };")
print("}\n")
print(FOOTER)
|
def emit(optimizer_parameter_map):
# Don't write generated with an @ in front, else this file is recognized as generated.
print("// @{} from {}".format("generated", __file__))
print(HEADER)
for optimizer_name, parameters in optimizer_parameter_map.items():
print(PARAMETERS.format(optimizer_name))
print(" return {")
for sample in parameters:
print(" {")
for parameter in sample:
parameter_values = "{{{}}}".format(", ".join(map(str, parameter)))
print(f" torch::tensor({parameter_values}),")
print(" },")
print(" };")
print("}\n")
print(FOOTER)
|
import argparse
import math
import sys
import torch
import torch.optim
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
OPTIMIZERS = {
"LBFGS" : lambda p: torch.optim.LBFGS(p, 1.0),
"LBFGS_with_line_search" : lambda p: torch.optim.LBFGS(p, 1.0, line_search_fn="strong_wolfe"),
"Adam": lambda p: torch.optim.Adam(p, 1.0),
"Adam_with_weight_decay": lambda p: torch.optim.Adam(p, 1.0, weight_decay=1e-2),
"Adam_with_weight_decay_and_amsgrad": lambda p: torch.optim.Adam(p, 1.0, weight_decay=1e-6, amsgrad=True),
"AdamW": lambda p: torch.optim.AdamW(p, 1.0),
"AdamW_without_weight_decay": lambda p: torch.optim.AdamW(p, 1.0, weight_decay=0),
"AdamW_with_amsgrad": lambda p: torch.optim.AdamW(p, 1.0, amsgrad=True),
"Adagrad": lambda p: torch.optim.Adagrad(p, 1.0),
"Adagrad_with_weight_decay": lambda p: torch.optim.Adagrad(p, 1.0, weight_decay=1e-2),
"Adagrad_with_weight_decay_and_lr_decay": lambda p: torch.optim.Adagrad(p, 1.0, weight_decay=1e-6, lr_decay=1e-3),
"RMSprop": lambda p: torch.optim.RMSprop(p, 0.1),
"RMSprop_with_weight_decay": lambda p: torch.optim.RMSprop(p, 0.1, weight_decay=1e-2),
"RMSprop_with_weight_decay_and_centered": lambda p: torch.optim.RMSprop(p, 0.1, weight_decay=1e-6, centered=True),
"RMSprop_with_weight_decay_and_centered_and_momentum":
lambda p: torch.optim.RMSprop(p, 0.1, weight_decay=1e-6, centered=True, momentum=0.9),
"SGD": lambda p: torch.optim.SGD(p, 0.1),
"SGD_with_weight_decay": lambda p: torch.optim.SGD(p, 0.1, weight_decay=1e-2),
"SGD_with_weight_decay_and_momentum": lambda p: torch.optim.SGD(p, 0.1, momentum=0.9, weight_decay=1e-2),
"SGD_with_weight_decay_and_nesterov_momentum":
lambda p: torch.optim.SGD(p, 0.1, momentum=0.9, weight_decay=1e-6, nesterov=True),
}
|
import argparse
import math
import sys
import torch
import torch.optim
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
OPTIMIZERS = {
"LBFGS": lambda p: torch.optim.LBFGS(p, 1.0),
"LBFGS_with_line_search": lambda p: torch.optim.LBFGS(
p, 1.0, line_search_fn="strong_wolfe"
),
"Adam": lambda p: torch.optim.Adam(p, 1.0),
"Adam_with_weight_decay": lambda p: torch.optim.Adam(p, 1.0, weight_decay=1e-2),
"Adam_with_weight_decay_and_amsgrad": lambda p: torch.optim.Adam(
p, 1.0, weight_decay=1e-6, amsgrad=True
),
"AdamW": lambda p: torch.optim.AdamW(p, 1.0),
"AdamW_without_weight_decay": lambda p: torch.optim.AdamW(p, 1.0, weight_decay=0),
"AdamW_with_amsgrad": lambda p: torch.optim.AdamW(p, 1.0, amsgrad=True),
"Adagrad": lambda p: torch.optim.Adagrad(p, 1.0),
"Adagrad_with_weight_decay": lambda p: torch.optim.Adagrad(
p, 1.0, weight_decay=1e-2
),
"Adagrad_with_weight_decay_and_lr_decay": lambda p: torch.optim.Adagrad(
p, 1.0, weight_decay=1e-6, lr_decay=1e-3
),
"RMSprop": lambda p: torch.optim.RMSprop(p, 0.1),
"RMSprop_with_weight_decay": lambda p: torch.optim.RMSprop(
p, 0.1, weight_decay=1e-2
),
"RMSprop_with_weight_decay_and_centered": lambda p: torch.optim.RMSprop(
p, 0.1, weight_decay=1e-6, centered=True
),
"RMSprop_with_weight_decay_and_centered_and_momentum": lambda p: torch.optim.RMSprop(
p, 0.1, weight_decay=1e-6, centered=True, momentum=0.9
),
"SGD": lambda p: torch.optim.SGD(p, 0.1),
"SGD_with_weight_decay": lambda p: torch.optim.SGD(p, 0.1, weight_decay=1e-2),
"SGD_with_weight_decay_and_momentum": lambda p: torch.optim.SGD(
p, 0.1, momentum=0.9, weight_decay=1e-2
),
"SGD_with_weight_decay_and_nesterov_momentum": lambda p: torch.optim.SGD(
p, 0.1, momentum=0.9, weight_decay=1e-6, nesterov=True
),
}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/api/optim_baseline.py
|
main
|
def main():
parser = argparse.ArgumentParser(
"Produce optimization output baseline from PyTorch"
)
parser.add_argument("-i", "--iterations", default=1001, type=int)
parser.add_argument("-s", "--sample-every", default=100, type=int)
options = parser.parse_args()
optimizer_parameter_map = {}
for optimizer in OPTIMIZERS.keys():
sys.stderr.write('Evaluating {} ...\n'.format(optimizer))
optimizer_parameter_map[optimizer] = run(
optimizer, options.iterations, options.sample_every
)
emit(optimizer_parameter_map)
if __name__ == "__main__":
main()
|
def main():
parser = argparse.ArgumentParser(
"Produce optimization output baseline from PyTorch"
)
parser.add_argument("-i", "--iterations", default=1001, type=int)
parser.add_argument("-s", "--sample-every", default=100, type=int)
options = parser.parse_args()
optimizer_parameter_map = {}
for optimizer in OPTIMIZERS.keys():
sys.stderr.write(f"Evaluating {optimizer} ...\n")
optimizer_parameter_map[optimizer] = run(
optimizer, options.iterations, options.sample_every
)
emit(optimizer_parameter_map)
if __name__ == "__main__":
main()
|
import argparse
import math
import sys
import torch
import torch.optim
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
OPTIMIZERS = {
"LBFGS" : lambda p: torch.optim.LBFGS(p, 1.0),
"LBFGS_with_line_search" : lambda p: torch.optim.LBFGS(p, 1.0, line_search_fn="strong_wolfe"),
"Adam": lambda p: torch.optim.Adam(p, 1.0),
"Adam_with_weight_decay": lambda p: torch.optim.Adam(p, 1.0, weight_decay=1e-2),
"Adam_with_weight_decay_and_amsgrad": lambda p: torch.optim.Adam(p, 1.0, weight_decay=1e-6, amsgrad=True),
"AdamW": lambda p: torch.optim.AdamW(p, 1.0),
"AdamW_without_weight_decay": lambda p: torch.optim.AdamW(p, 1.0, weight_decay=0),
"AdamW_with_amsgrad": lambda p: torch.optim.AdamW(p, 1.0, amsgrad=True),
"Adagrad": lambda p: torch.optim.Adagrad(p, 1.0),
"Adagrad_with_weight_decay": lambda p: torch.optim.Adagrad(p, 1.0, weight_decay=1e-2),
"Adagrad_with_weight_decay_and_lr_decay": lambda p: torch.optim.Adagrad(p, 1.0, weight_decay=1e-6, lr_decay=1e-3),
"RMSprop": lambda p: torch.optim.RMSprop(p, 0.1),
"RMSprop_with_weight_decay": lambda p: torch.optim.RMSprop(p, 0.1, weight_decay=1e-2),
"RMSprop_with_weight_decay_and_centered": lambda p: torch.optim.RMSprop(p, 0.1, weight_decay=1e-6, centered=True),
"RMSprop_with_weight_decay_and_centered_and_momentum":
lambda p: torch.optim.RMSprop(p, 0.1, weight_decay=1e-6, centered=True, momentum=0.9),
"SGD": lambda p: torch.optim.SGD(p, 0.1),
"SGD_with_weight_decay": lambda p: torch.optim.SGD(p, 0.1, weight_decay=1e-2),
"SGD_with_weight_decay_and_momentum": lambda p: torch.optim.SGD(p, 0.1, momentum=0.9, weight_decay=1e-2),
"SGD_with_weight_decay_and_nesterov_momentum":
lambda p: torch.optim.SGD(p, 0.1, momentum=0.9, weight_decay=1e-6, nesterov=True),
}
|
import argparse
import math
import sys
import torch
import torch.optim
HEADER = """
#include <torch/types.h>
#include <vector>
namespace expected_parameters {
"""
FOOTER = "} // namespace expected_parameters"
PARAMETERS = "inline std::vector<std::vector<torch::Tensor>> {}() {{"
OPTIMIZERS = {
"LBFGS": lambda p: torch.optim.LBFGS(p, 1.0),
"LBFGS_with_line_search": lambda p: torch.optim.LBFGS(
p, 1.0, line_search_fn="strong_wolfe"
),
"Adam": lambda p: torch.optim.Adam(p, 1.0),
"Adam_with_weight_decay": lambda p: torch.optim.Adam(p, 1.0, weight_decay=1e-2),
"Adam_with_weight_decay_and_amsgrad": lambda p: torch.optim.Adam(
p, 1.0, weight_decay=1e-6, amsgrad=True
),
"AdamW": lambda p: torch.optim.AdamW(p, 1.0),
"AdamW_without_weight_decay": lambda p: torch.optim.AdamW(p, 1.0, weight_decay=0),
"AdamW_with_amsgrad": lambda p: torch.optim.AdamW(p, 1.0, amsgrad=True),
"Adagrad": lambda p: torch.optim.Adagrad(p, 1.0),
"Adagrad_with_weight_decay": lambda p: torch.optim.Adagrad(
p, 1.0, weight_decay=1e-2
),
"Adagrad_with_weight_decay_and_lr_decay": lambda p: torch.optim.Adagrad(
p, 1.0, weight_decay=1e-6, lr_decay=1e-3
),
"RMSprop": lambda p: torch.optim.RMSprop(p, 0.1),
"RMSprop_with_weight_decay": lambda p: torch.optim.RMSprop(
p, 0.1, weight_decay=1e-2
),
"RMSprop_with_weight_decay_and_centered": lambda p: torch.optim.RMSprop(
p, 0.1, weight_decay=1e-6, centered=True
),
"RMSprop_with_weight_decay_and_centered_and_momentum": lambda p: torch.optim.RMSprop(
p, 0.1, weight_decay=1e-6, centered=True, momentum=0.9
),
"SGD": lambda p: torch.optim.SGD(p, 0.1),
"SGD_with_weight_decay": lambda p: torch.optim.SGD(p, 0.1, weight_decay=1e-2),
"SGD_with_weight_decay_and_momentum": lambda p: torch.optim.SGD(
p, 0.1, momentum=0.9, weight_decay=1e-2
),
"SGD_with_weight_decay_and_nesterov_momentum": lambda p: torch.optim.SGD(
p, 0.1, momentum=0.9, weight_decay=1e-6, nesterov=True
),
}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp_extensions/open_registration_extension/pytorch_openreg/_meta_parser.py
|
convert
|
def convert(obj):
if isinstance(obj, torch.Tensor):
return str(OpenRegTensorMeta(obj, checked=False))
else:
return obj
new_args = tree_map(convert, args)
return pprint.pformat(new_args)
|
import pprint
import torch
from torch.utils._pytree import tree_map, tree_map_only
VALID_QUEUE_TYPES_IN = {torch.Tensor, int, float}
VALID_QUEUE_TYPES_OUT = {OpenRegTensorMeta, int, float, str}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/pytorch_openreg/_meta_parser.py
|
convert
|
def convert(obj):
if isinstance(obj, torch.Tensor):
return str(OpenRegTensorMeta(obj, checked=False))
else:
return obj
new_args = tree_map(convert, args)
return pprint.pformat(new_args)
|
import pprint
import torch
from torch.utils._pytree import tree_map, tree_map_only
VALID_QUEUE_TYPES_IN = {torch.Tensor, int, float}
VALID_QUEUE_TYPES_OUT = {OpenRegTensorMeta, int, float, str}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/pytorch_openreg/_meta_parser.py
|
safe_to
|
def safe_to(t):
if device == "meta":
return t.to(device=device)
else:
return torch.empty_like(t, device=device)
return tree_map_only(torch.Tensor, safe_to, (args, kwargs))
|
import pprint
import torch
from torch.utils._pytree import tree_map, tree_map_only
VALID_QUEUE_TYPES_IN = {torch.Tensor, int, float}
VALID_QUEUE_TYPES_OUT = {OpenRegTensorMeta, int, float, str}
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/setup.py
|
run
|
def run(self):
# Run default behavior first
distutils.command.clean.clean.run(self)
# Remove pytorch_openreg extension
for path in (ROOT_DIR / "pytorch_openreg").glob("**/*.so"):
path.unlink()
# Remove build directory
build_dirs = [
ROOT_DIR / "build",
]
for path in build_dirs:
if path.exists():
shutil.rmtree(str(path), ignore_errors=True)
|
import distutils.command.clean
import shutil
from pathlib import Path
from setuptools import find_packages, setup
from torch.utils.cpp_extension import BuildExtension, CppExtension
PACKAGE_NAME = "pytorch_openreg"
version = 1.0
ROOT_DIR = Path(__file__).absolute().parent
CSRS_DIR = ROOT_DIR / "pytorch_openreg/csrc"
class clean(distutils.command.clean.clean):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/test/test_openreg.py
|
test_autograd_init
|
def test_autograd_init(self):
# Make sure autograd is initialized
torch.ones(2, requires_grad=True, device="openreg").sum().backward()
pid = os.getpid()
task_path = f"/proc/{pid}/task"
all_threads = psutil.Process(pid).threads()
all_thread_names = set()
for t in all_threads:
with open(f"{task_path}/{t.id}/comm") as file:
thread_name = file.read().strip()
all_thread_names.add(thread_name)
for i in range(pytorch_openreg._device_daemon.NUM_DEVICES):
self.assertIn(f"pt_autograd_{i}", all_thread_names)
|
import os
import unittest
import psutil
import pytorch_openreg
import torch
from torch.testing._internal.common_utils import run_tests, TestCase
class TestOpenReg(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/test/test_openreg.py
|
test_factory
|
def test_factory(self):
a = torch.empty(50, device="openreg")
self.assertEqual(a.device.type, "openreg")
a.fill_(3.5)
self.assertTrue(a.eq(3.5).all())
|
import os
import unittest
import psutil
import pytorch_openreg
import torch
from torch.testing._internal.common_utils import run_tests, TestCase
class TestOpenReg(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/test/test_openreg.py
|
test_printing
|
def test_printing(self):
a = torch.ones(20, device="openreg")
# Does not crash!
str(a)
|
import os
import unittest
import psutil
import pytorch_openreg
import torch
from torch.testing._internal.common_utils import run_tests, TestCase
class TestOpenReg(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/test/test_openreg.py
|
test_cross_device_copy
|
def test_cross_device_copy(self):
a = torch.rand(10)
b = a.to(device="openreg").add(2).to(device="cpu")
self.assertEqual(b, a + 2)
|
import os
import unittest
import psutil
import pytorch_openreg
import torch
from torch.testing._internal.common_utils import run_tests, TestCase
class TestOpenReg(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp_extensions/open_registration_extension/test/test_openreg.py
|
test_data_dependent_output
|
def test_data_dependent_output(self):
cpu_a = torch.randn(10)
a = cpu_a.to(device="openreg")
mask = a.gt(0)
out = torch.masked_select(a, mask)
self.assertEqual(out, cpu_a.masked_select(cpu_a.gt(0)))
|
import os
import unittest
import psutil
import pytorch_openreg
import torch
from torch.testing._internal.common_utils import run_tests, TestCase
class TestOpenReg(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/conftest.py
|
pytest_sessionfinish
|
def pytest_sessionfinish(self, session, exitstatus):
if exitstatus == 0 and not self.run_single:
self.cache.set(self.directory, self.initial_val)
|
import copy
import functools
import json
import os
import re
import sys
import xml.etree.ElementTree as ET
from collections import defaultdict
from types import MethodType
from typing import Any, List, Optional, TYPE_CHECKING, Union
import pytest
from _pytest.config import Config, filename_arg
from _pytest.config.argparsing import Parser
from _pytest.junitxml import _NodeReporter, bin_xml_escape, LogXML
from _pytest.python import Module
from _pytest.reports import TestReport
from _pytest.stash import StashKey
from _pytest.terminal import _get_raw_skip_reason
from pytest_shard_custom import pytest_addoptions as shard_addoptions, PytestShardPlugin
from _pytest._code.code import ReprFileLocation
xml_key = StashKey["LogXMLReruns"]()
STEPCURRENT_CACHE_DIR = "cache/stepcurrent"
class StepcurrentPlugin:
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/compile_model.py
|
__init__
|
def __init__(self, data):
super().__init__()
for key in data:
setattr(self, key, data[key])
|
import torch
from torch.export import Dim
AOTI_CUSTOM_OP_LIB = "libaoti_custom_class.so"
class TensorSerializer(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/compile_model.py
|
forward
|
def forward(self, x):
a = self.fc(x)
b = self.relu(a)
return b
|
import torch
from torch.export import Dim
AOTI_CUSTOM_OP_LIB = "libaoti_custom_class.so"
class SimpleModule(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/compile_model.py
|
__init__
|
def __init__(self, data):
super().__init__()
for key in data:
setattr(self, key, data[key])
|
import torch
from torch.export import Dim
AOTI_CUSTOM_OP_LIB = "libaoti_custom_class.so"
class TensorSerializer(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/compile_model.py
|
forward
|
def forward(self, x):
a = self.fc(x)
b = self.relu(a)
return b
|
import torch
from torch.export import Dim
AOTI_CUSTOM_OP_LIB = "libaoti_custom_class.so"
class SimpleModule(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/compile_model.py
|
make_script_module
|
def make_script_module(lib_path, device, *inputs):
m = MyAOTIModule(lib_path, device)
# sanity check
m(*inputs)
return torch.jit.trace(m, inputs)
|
import torch
from torch.export import Dim
AOTI_CUSTOM_OP_LIB = "libaoti_custom_class.so"
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/compile_model.py
|
compile_model
|
def compile_model(device, data):
module = SimpleModule().to(device)
x = torch.randn((4, 4), device=device)
inputs = (x,)
# make batch dimension
batch_dim = Dim("batch", min=1, max=1024)
dynamic_shapes = {
"x": {0: batch_dim},
}
with torch.no_grad():
# aot-compile the module into a .so pointed by lib_path
lib_path = torch._export.aot_compile(
module, inputs, dynamic_shapes=dynamic_shapes
)
script_module = make_script_module(lib_path, device, *inputs)
aoti_script_model = f"script_model_{device}.pt"
script_module.save(aoti_script_model)
# save sample inputs and ref output
with torch.no_grad():
ref_output = module(*inputs)
data.update(
{
f"inputs_{device}": list(inputs),
f"outputs_{device}": [ref_output],
}
)
|
import torch
from torch.export import Dim
AOTI_CUSTOM_OP_LIB = "libaoti_custom_class.so"
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/compile_model.py
|
main
|
def main():
data = {}
for device in ["cpu", "cuda"] if torch.cuda.is_available() else ["cpu"]:
compile_model(device, data)
torch.jit.script(TensorSerializer(data)).save("script_data.pt")
if __name__ == "__main__":
main()
|
import torch
from torch.export import Dim
AOTI_CUSTOM_OP_LIB = "libaoti_custom_class.so"
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/aoti_inference/test.py
|
__init__
|
def __init__(self, device):
super().__init__()
self.w_pre = torch.randn(4, 4, device=device)
self.w_add = torch.randn(4, 4, device=device)
|
import torch
from torch._export import aot_compile
from torch.export import Dim
class Net(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/cpp/jit/tests_setup.py
|
shutdown
|
def shutdown(self):
raise NotImplementedError()
|
def shutdown(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/jit/tests_setup.py
|
shutdown
|
def shutdown(self):
raise NotImplementedError()
|
def shutdown(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/jit/tests_setup.py
|
setup
|
def setup(self):
raise NotImplementedError()
|
def setup(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/jit/tests_setup.py
|
setup
|
def setup(self):
raise NotImplementedError()
|
def setup(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/jit/tests_setup.py
|
setup
|
def setup(self):
raise NotImplementedError()
|
def setup(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/jit/tests_setup.py
|
setup
|
def setup(self):
raise NotImplementedError()
|
def setup(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp/jit/tests_setup.py
|
setup
|
def setup(self):
raise NotImplementedError()
|
def setup(self):
raise NotImplementedError
|
import sys
import os
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA()
]
|
import os
import sys
import torch
tests = [
EvalModeForLoadedModule(),
SerializationInterop(),
TorchSaveError(),
TorchSaveJitStream_CUDA(),
]
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/cpp_api_parity/utils.py
|
generate_error_msg
|
def generate_error_msg(name, cpp_value, python_value):
return (
"Parity test failed: {} in C++ has value: {}, "
"which does not match the corresponding value in Python: {}.\n{}").format(
name, cpp_value, python_value, MESSAGE_HOW_TO_FIX_CPP_PARITY_TEST_FAILURE)
|
def generate_error_msg(name, cpp_value, python_value):
return (
f"Parity test failed: {name} in C++ has value: {cpp_value}, "
f"which does not match the corresponding value in Python: {python_value}.\n{MESSAGE_HOW_TO_FIX_CPP_PARITY_TEST_FAILURE}"
)
|
from collections import namedtuple
import unittest
import os
import warnings
import shutil
import torch
import torch.utils.cpp_extension
import torch.testing._internal.common_nn as common_nn
from torch.testing._internal.common_cuda import TEST_CUDA
TorchNNModuleTestParams = namedtuple(
'TorchNNModuleTestParams',
[
# NN module name (e.g. "BCELoss")
'module_name',
# Unique identifier for this module config (e.g. "BCELoss_weights_cuda")
'module_variant_name',
# An instance of an NN test class (e.g. `CriterionTest`) which stores
# necessary information (e.g. input / target / extra_args) for running the Python test
'test_instance',
# Constructor arguments passed to the C++ module constructor, which must be
# strictly equivalent to the Python module constructor arguments
# (e.g. `torch::nn::BCELossOptions().weight(torch::rand(10))`,
# which is strictly equivalent to passing `torch.rand(10)` to `torch.nn.BCELoss`
# constructor in Python)
'cpp_constructor_args',
# All arguments used in NN module's forward pass.
# Please see `compute_arg_dict` function for details on how we construct this dict.
# (e.g.
# ```
# arg_dict = {
# 'input': [python_input_tensor],
# 'target': [python_target_tensor],
# 'extra_args': [],
# 'other': [],
# }
# ```
# )
'arg_dict',
# Whether we expect this NN module test to pass the Python/C++ parity test
# (e.g. `True`)
'has_parity',
# Device (e.g. "cuda")
'device',
# Temporary folder to store C++ outputs (to be compared with Python outputs later)
'cpp_tmp_folder',
]
)
TorchNNFunctionalTestParams = namedtuple(
'TorchNNFunctionalTestParams',
[
# NN functional name (e.g. "binary_cross_entropy")
'functional_name',
# Unique identifier for this functional config (e.g. "BCELoss_no_reduce_cuda")
'functional_variant_name',
# An instance of an NN test class (e.g. `NewModuleTest`) which stores
# necessary information (e.g. input / target / extra_args) for running the Python test
'test_instance',
# The C++ function call that is strictly equivalent to the Python function call
# (e.g. "F::binary_cross_entropy(
# i, t.to(i.options()),F::BinaryCrossEntropyFuncOptions().reduction(torch::kNone))",
# which is strictly equivalent to `F.binary_cross_entropy(i, t.type_as(i), reduction='none')` in Python)
'cpp_function_call',
# All arguments used in NN functional's function call.
# Please see `compute_arg_dict` function for details on how we construct this dict.
# (e.g.
# ```
# arg_dict = {
# 'input': [python_input_tensor],
# 'target': [python_target_tensor],
# 'extra_args': [],
# 'other': [],
# }
# ```
# )
'arg_dict',
# Whether we expect this NN functional test to pass the Python/C++ parity test
# (e.g. `True`)
'has_parity',
# Device (e.g. "cuda")
'device',
# Temporary folder to store C++ outputs (to be compared with Python outputs later)
'cpp_tmp_folder',
]
)
CppArg = namedtuple('CppArg', ['name', 'value'])
TORCH_NN_COMMON_TEST_HARNESS = """
#include <torch/script.h>
void write_ivalue_to_file(const torch::IValue& ivalue, const std::string& file_path) {
auto bytes = torch::jit::pickle_save(ivalue);
std::ofstream fout(file_path, std::ios::out | std::ios::binary);
fout.write(bytes.data(), bytes.size());
fout.close();
}
c10::Dict<std::string, torch::Tensor> load_dict_from_file(const std::string& file_path) {
c10::Dict<std::string, torch::Tensor> arg_dict;
auto arg_dict_module = torch::jit::load(file_path);
for (const auto& p : arg_dict_module.named_buffers(/*recurse=*/false)) {
arg_dict.insert(p.name, p.value);
}
return arg_dict;
}
// Generates rand tensor with non-equal values. This ensures that duplicate
// values won't be causing test failure for modules like MaxPooling.
// size should be small, otherwise randperm fails / long overflows.
torch::Tensor _rand_tensor_non_equal(torch::IntArrayRef size) {
int64_t total = 1;
for (int64_t elem : size) {
total *= elem;
}
return torch::randperm(total).view(size).to(torch::kDouble);
}
"""
MESSAGE_HOW_TO_FIX_CPP_PARITY_TEST_FAILURE = '''
What should I do when C++ API parity test is failing?
- If you are changing the implementation of an existing `torch.nn` module / `torch.nn.functional` function:
Answer: Ideally you should also change the C++ API implementation for that module / function
(you can start by searching for the module / function name in `torch/csrc/api/` folder).
- If you are adding a new test for an existing `torch.nn` module / `torch.nn.functional` function:
Answer: Ideally you should fix the C++ API implementation for that module / function
to exactly match the Python API implementation (you can start by searching for the module /
function name in `torch/csrc/api/` folder).
- If you are adding a test for a *new* `torch.nn` module / `torch.nn.functional` function:
Answer: Ideally you should add the corresponding C++ API implementation for that module / function,
and it should exactly match the Python API implementation. (We have done a large effort on this
which is tracked at https://github.com/pytorch/pytorch/issues/25883.)
However, if any of the above is proven to be too complicated, you can just add
`test_cpp_api_parity=False` to any failing test in `torch/testing/_internal/common_nn.py`,
and the C++ API parity test will be skipped accordingly. Note that you should
also file an issue when you do this.
For more details on how to add a C++ API parity test, please see:
NOTE [How to check NN module / functional API parity between Python and C++ frontends]
'''
|
import os
import shutil
import unittest
import warnings
from collections import namedtuple
import torch
import torch.testing._internal.common_nn as common_nn
import torch.utils.cpp_extension
from torch.testing._internal.common_cuda import TEST_CUDA
TorchNNModuleTestParams = namedtuple(
"TorchNNModuleTestParams",
[
# NN module name (e.g. "BCELoss")
"module_name",
# Unique identifier for this module config (e.g. "BCELoss_weights_cuda")
"module_variant_name",
# An instance of an NN test class (e.g. `CriterionTest`) which stores
# necessary information (e.g. input / target / extra_args) for running the Python test
"test_instance",
# Constructor arguments passed to the C++ module constructor, which must be
# strictly equivalent to the Python module constructor arguments
# (e.g. `torch::nn::BCELossOptions().weight(torch::rand(10))`,
# which is strictly equivalent to passing `torch.rand(10)` to `torch.nn.BCELoss`
# constructor in Python)
"cpp_constructor_args",
# All arguments used in NN module's forward pass.
# Please see `compute_arg_dict` function for details on how we construct this dict.
# (e.g.
# ```
# arg_dict = {
# 'input': [python_input_tensor],
# 'target': [python_target_tensor],
# 'extra_args': [],
# 'other': [],
# }
# ```
# )
"arg_dict",
# Whether we expect this NN module test to pass the Python/C++ parity test
# (e.g. `True`)
"has_parity",
# Device (e.g. "cuda")
"device",
# Temporary folder to store C++ outputs (to be compared with Python outputs later)
"cpp_tmp_folder",
],
)
TorchNNFunctionalTestParams = namedtuple(
"TorchNNFunctionalTestParams",
[
# NN functional name (e.g. "binary_cross_entropy")
"functional_name",
# Unique identifier for this functional config (e.g. "BCELoss_no_reduce_cuda")
"functional_variant_name",
# An instance of an NN test class (e.g. `NewModuleTest`) which stores
# necessary information (e.g. input / target / extra_args) for running the Python test
"test_instance",
# The C++ function call that is strictly equivalent to the Python function call
# (e.g. "F::binary_cross_entropy(
# i, t.to(i.options()),F::BinaryCrossEntropyFuncOptions().reduction(torch::kNone))",
# which is strictly equivalent to `F.binary_cross_entropy(i, t.type_as(i), reduction='none')` in Python)
"cpp_function_call",
# All arguments used in NN functional's function call.
# Please see `compute_arg_dict` function for details on how we construct this dict.
# (e.g.
# ```
# arg_dict = {
# 'input': [python_input_tensor],
# 'target': [python_target_tensor],
# 'extra_args': [],
# 'other': [],
# }
# ```
# )
"arg_dict",
# Whether we expect this NN functional test to pass the Python/C++ parity test
# (e.g. `True`)
"has_parity",
# Device (e.g. "cuda")
"device",
# Temporary folder to store C++ outputs (to be compared with Python outputs later)
"cpp_tmp_folder",
],
)
CppArg = namedtuple("CppArg", ["name", "value"])
TORCH_NN_COMMON_TEST_HARNESS = """
#include <torch/script.h>
void write_ivalue_to_file(const torch::IValue& ivalue, const std::string& file_path) {
auto bytes = torch::jit::pickle_save(ivalue);
std::ofstream fout(file_path, std::ios::out | std::ios::binary);
fout.write(bytes.data(), bytes.size());
fout.close();
}
c10::Dict<std::string, torch::Tensor> load_dict_from_file(const std::string& file_path) {
c10::Dict<std::string, torch::Tensor> arg_dict;
auto arg_dict_module = torch::jit::load(file_path);
for (const auto& p : arg_dict_module.named_buffers(/*recurse=*/false)) {
arg_dict.insert(p.name, p.value);
}
return arg_dict;
}
// Generates rand tensor with non-equal values. This ensures that duplicate
// values won't be causing test failure for modules like MaxPooling.
// size should be small, otherwise randperm fails / long overflows.
torch::Tensor _rand_tensor_non_equal(torch::IntArrayRef size) {
int64_t total = 1;
for (int64_t elem : size) {
total *= elem;
}
return torch::randperm(total).view(size).to(torch::kDouble);
}
"""
MESSAGE_HOW_TO_FIX_CPP_PARITY_TEST_FAILURE = """
What should I do when C++ API parity test is failing?
- If you are changing the implementation of an existing `torch.nn` module / `torch.nn.functional` function:
Answer: Ideally you should also change the C++ API implementation for that module / function
(you can start by searching for the module / function name in `torch/csrc/api/` folder).
- If you are adding a new test for an existing `torch.nn` module / `torch.nn.functional` function:
Answer: Ideally you should fix the C++ API implementation for that module / function
to exactly match the Python API implementation (you can start by searching for the module /
function name in `torch/csrc/api/` folder).
- If you are adding a test for a *new* `torch.nn` module / `torch.nn.functional` function:
Answer: Ideally you should add the corresponding C++ API implementation for that module / function,
and it should exactly match the Python API implementation. (We have done a large effort on this
which is tracked at https://github.com/pytorch/pytorch/issues/25883.)
However, if any of the above is proven to be too complicated, you can just add
`test_cpp_api_parity=False` to any failing test in `torch/testing/_internal/common_nn.py`,
and the C++ API parity test will be skipped accordingly. Note that you should
also file an issue when you do this.
For more details on how to add a C++ API parity test, please see:
NOTE [How to check NN module / functional API parity between Python and C++ frontends]
"""
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 8