wehub-resource-sync
415 lines
14 KiB
Python
415 lines
14 KiB
Python
# Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
import unittest
|
|
|
|
import paddle
|
|
|
|
|
|
class TestUtilsAttrError(unittest.TestCase):
|
|
def test_error(self):
|
|
with self.assertRaises(AttributeError):
|
|
type(paddle.utils.nonexist)
|
|
|
|
|
|
class TestAlias(unittest.TestCase):
|
|
def test_utils_data_api_alias(self):
|
|
api_map = [
|
|
(
|
|
paddle.io.Dataset,
|
|
paddle.utils.data.Dataset,
|
|
paddle.utils.data.dataset.Dataset,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.ChainDataset,
|
|
paddle.utils.data.ChainDataset,
|
|
paddle.utils.data.dataset.ChainDataset,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.ConcatDataset,
|
|
paddle.utils.data.ConcatDataset,
|
|
paddle.utils.data.dataset.ConcatDataset,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.IterableDataset,
|
|
paddle.utils.data.IterableDataset,
|
|
paddle.utils.data.dataset.IterableDataset,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.Sampler,
|
|
paddle.utils.data.Sampler,
|
|
paddle.utils.data.sampler.Sampler,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.SequenceSampler,
|
|
paddle.utils.data.SequentialSampler,
|
|
paddle.utils.data.sampler.SequentialSampler,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.Subset,
|
|
paddle.utils.data.Subset,
|
|
paddle.utils.data.dataset.Subset,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.get_worker_info,
|
|
paddle.utils.data.get_worker_info,
|
|
paddle.utils.data.dataloader.get_worker_info,
|
|
paddle.utils.data._utils.worker.get_worker_info,
|
|
),
|
|
(
|
|
paddle.io.random_split,
|
|
paddle.utils.data.random_split,
|
|
paddle.utils.data.dataset.random_split,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.dataloader.collate.default_collate_fn,
|
|
paddle.utils.data.default_collate,
|
|
paddle.utils.data.dataloader.default_collate,
|
|
paddle.utils.data._utils.collate.default_collate,
|
|
),
|
|
(
|
|
paddle.io.BatchSampler,
|
|
paddle.utils.data.BatchSampler,
|
|
paddle.utils.data.sampler.BatchSampler,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.RandomSampler,
|
|
paddle.utils.data.RandomSampler,
|
|
paddle.utils.data.sampler.RandomSampler,
|
|
None,
|
|
),
|
|
(
|
|
paddle.io.TensorDataset,
|
|
paddle.utils.data.TensorDataset,
|
|
paddle.utils.data.dataset.TensorDataset,
|
|
None,
|
|
),
|
|
]
|
|
self.assert_api_map(api_map)
|
|
|
|
def test_optimizer_import_usages(self):
|
|
import paddle.optim.adadelta
|
|
import paddle.optim.lr_scheduler
|
|
from paddle import optim
|
|
from paddle.optim import lr_scheduler
|
|
from paddle.optim.adadelta import Adadelta
|
|
from paddle.optim.lr_scheduler import ConstantLR
|
|
|
|
self.assertIs(paddle.optim, optim)
|
|
api_map = [
|
|
(
|
|
paddle.optimizer.Adadelta,
|
|
paddle.optim.Adadelta,
|
|
paddle.optim.adadelta.Adadelta,
|
|
Adadelta,
|
|
),
|
|
(paddle.optimizer.Adagrad, paddle.optim.Adagrad),
|
|
(paddle.optimizer.Adam, paddle.optim.Adam),
|
|
(paddle.optimizer.Adamax, paddle.optim.Adamax),
|
|
(paddle.optimizer.AdamW, paddle.optim.AdamW),
|
|
(paddle.optimizer.ASGD, paddle.optim.ASGD),
|
|
(paddle.optimizer.LBFGS, paddle.optim.LBFGS),
|
|
(paddle.optimizer.Muon, paddle.optim.Muon),
|
|
(paddle.optimizer.NAdam, paddle.optim.NAdam),
|
|
(paddle.optimizer.Optimizer, paddle.optim.Optimizer),
|
|
(paddle.optimizer.RAdam, paddle.optim.RAdam),
|
|
(paddle.optimizer.RMSProp, paddle.optim.RMSProp),
|
|
(paddle.optimizer.Rprop, paddle.optim.Rprop),
|
|
(paddle.optimizer.SGD, paddle.optim.SGD),
|
|
(
|
|
paddle.optimizer.lr.PiecewiseDecay,
|
|
paddle.optim.lr_scheduler.ConstantLR,
|
|
lr_scheduler.ConstantLR,
|
|
ConstantLR,
|
|
),
|
|
]
|
|
self.assertIs(paddle.optim.lr_scheduler, lr_scheduler)
|
|
self.assert_api_map(api_map)
|
|
|
|
def test_lr_scheduler_api_alias(self):
|
|
import paddle.optim.lr_scheduler
|
|
import paddle.optimizer.lr
|
|
from paddle.optim import lr_scheduler
|
|
from paddle.optim.lr_scheduler import (
|
|
ConstantLR,
|
|
CosineAnnealingLR,
|
|
CosineAnnealingWarmRestarts,
|
|
CyclicLR,
|
|
ExponentialLR,
|
|
LambdaLR,
|
|
LinearLR,
|
|
LRScheduler,
|
|
MultiplicativeLR,
|
|
MultiStepLR,
|
|
OneCycleLR,
|
|
ReduceLROnPlateau,
|
|
StepLR,
|
|
)
|
|
|
|
api_map = [
|
|
(
|
|
paddle.optimizer.lr.PiecewiseDecay,
|
|
paddle.optim.lr_scheduler.ConstantLR,
|
|
lr_scheduler.ConstantLR,
|
|
ConstantLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.CosineAnnealingDecay,
|
|
paddle.optim.lr_scheduler.CosineAnnealingLR,
|
|
lr_scheduler.CosineAnnealingLR,
|
|
CosineAnnealingLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.CosineAnnealingWarmRestarts,
|
|
paddle.optim.lr_scheduler.CosineAnnealingWarmRestarts,
|
|
lr_scheduler.CosineAnnealingWarmRestarts,
|
|
CosineAnnealingWarmRestarts,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.CyclicLR,
|
|
paddle.optim.lr_scheduler.CyclicLR,
|
|
lr_scheduler.CyclicLR,
|
|
CyclicLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.ExponentialDecay,
|
|
paddle.optim.lr_scheduler.ExponentialLR,
|
|
lr_scheduler.ExponentialLR,
|
|
ExponentialLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.LRScheduler,
|
|
paddle.optim.lr_scheduler.LRScheduler,
|
|
lr_scheduler.LRScheduler,
|
|
LRScheduler,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.LambdaDecay,
|
|
paddle.optim.lr_scheduler.LambdaLR,
|
|
lr_scheduler.LambdaLR,
|
|
LambdaLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.LinearLR,
|
|
paddle.optim.lr_scheduler.LinearLR,
|
|
lr_scheduler.LinearLR,
|
|
LinearLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.MultiStepDecay,
|
|
paddle.optim.lr_scheduler.MultiStepLR,
|
|
lr_scheduler.MultiStepLR,
|
|
MultiStepLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.MultiplicativeDecay,
|
|
paddle.optim.lr_scheduler.MultiplicativeLR,
|
|
lr_scheduler.MultiplicativeLR,
|
|
MultiplicativeLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.OneCycleLR,
|
|
paddle.optim.lr_scheduler.OneCycleLR,
|
|
lr_scheduler.OneCycleLR,
|
|
OneCycleLR,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.ReduceOnPlateau,
|
|
paddle.optim.lr_scheduler.ReduceLROnPlateau,
|
|
lr_scheduler.ReduceLROnPlateau,
|
|
ReduceLROnPlateau,
|
|
),
|
|
(
|
|
paddle.optimizer.lr.StepDecay,
|
|
paddle.optim.lr_scheduler.StepLR,
|
|
lr_scheduler.StepLR,
|
|
StepLR,
|
|
),
|
|
]
|
|
self.assertIs(paddle.optim.lr_scheduler, lr_scheduler)
|
|
self.assert_api_map(api_map)
|
|
|
|
def test_distribution_import_usages(self):
|
|
import importlib
|
|
import sys
|
|
|
|
import paddle.distribution
|
|
import paddle.distribution.normal
|
|
import paddle.distributions
|
|
import paddle.distributions.normal
|
|
from paddle import distribution, distributions
|
|
from paddle.distribution import Normal as DistributionNormal
|
|
from paddle.distribution.normal import Normal as DistributionSubNormal
|
|
from paddle.distributions import Normal as DistributionsNormal
|
|
from paddle.distributions.normal import Normal as DistributionsSubNormal
|
|
|
|
self.assertIs(paddle.distribution, distribution)
|
|
self.assertIs(paddle.distributions, distributions)
|
|
self.assertIs(paddle.distribution, paddle.distributions)
|
|
self.assertIs(
|
|
sys.modules["paddle.distribution"],
|
|
sys.modules["paddle.distributions"],
|
|
)
|
|
|
|
self.assert_distribution_api_aliases()
|
|
self.assertIs(
|
|
paddle.distribution.constraints, paddle.distribution.constraint
|
|
)
|
|
self.assertIs(
|
|
paddle.distributions.constraints, paddle.distribution.constraint
|
|
)
|
|
|
|
submodule_api_map = [
|
|
("bernoulli", "Bernoulli"),
|
|
("beta", "Beta"),
|
|
("binomial", "Binomial"),
|
|
("categorical", "Categorical"),
|
|
("cauchy", "Cauchy"),
|
|
("chi2", "Chi2"),
|
|
("constraint", "Constraint"),
|
|
("continuous_bernoulli", "ContinuousBernoulli"),
|
|
("dirichlet", "Dirichlet"),
|
|
("distribution", "Distribution"),
|
|
("exponential", "Exponential"),
|
|
("exponential_family", "ExponentialFamily"),
|
|
("gamma", "Gamma"),
|
|
("geometric", "Geometric"),
|
|
("gumbel", "Gumbel"),
|
|
("independent", "Independent"),
|
|
("laplace", "Laplace"),
|
|
("lkj_cholesky", "LKJCholesky"),
|
|
("lognormal", "LogNormal"),
|
|
("multinomial", "Multinomial"),
|
|
("multivariate_normal", "MultivariateNormal"),
|
|
("normal", "Normal"),
|
|
("poisson", "Poisson"),
|
|
("student_t", "StudentT"),
|
|
("transform", "Transform"),
|
|
("transformed_distribution", "TransformedDistribution"),
|
|
("uniform", "Uniform"),
|
|
("variable", "Variable"),
|
|
]
|
|
for module_name, api_name in submodule_api_map:
|
|
self.assert_distribution_submodule_import(
|
|
importlib, module_name, api_name
|
|
)
|
|
|
|
normal_usages = [
|
|
DistributionNormal,
|
|
DistributionsNormal,
|
|
DistributionSubNormal,
|
|
DistributionsSubNormal,
|
|
paddle.distribution.Normal,
|
|
paddle.distributions.Normal,
|
|
paddle.distribution.normal.Normal,
|
|
paddle.distributions.normal.Normal,
|
|
]
|
|
self.assert_normal_usages_equal(normal_usages)
|
|
|
|
def test_random_api_alias(self):
|
|
self.assertIs(paddle.random.initial_seed, paddle.initial_seed)
|
|
|
|
def assert_distribution_api_aliases(self):
|
|
api_names = [
|
|
"Bernoulli",
|
|
"Beta",
|
|
"Binomial",
|
|
"Categorical",
|
|
"Cauchy",
|
|
"Chi2",
|
|
"ContinuousBernoulli",
|
|
"Dirichlet",
|
|
"Distribution",
|
|
"Exponential",
|
|
"ExponentialFamily",
|
|
"Gamma",
|
|
"Geometric",
|
|
"Gumbel",
|
|
"Independent",
|
|
"Laplace",
|
|
"LKJCholesky",
|
|
"LogNormal",
|
|
"Multinomial",
|
|
"MultivariateNormal",
|
|
"Normal",
|
|
"Poisson",
|
|
"StudentT",
|
|
"Transform",
|
|
"TransformedDistribution",
|
|
"Uniform",
|
|
]
|
|
for api_name in api_names:
|
|
self.assertIs(
|
|
getattr(paddle.distribution, api_name),
|
|
getattr(paddle.distributions, api_name),
|
|
)
|
|
|
|
def assert_distribution_submodule_import(
|
|
self, importlib, module_name, api_name
|
|
):
|
|
distribution_module = importlib.import_module(
|
|
f"paddle.distribution.{module_name}"
|
|
)
|
|
distributions_module = importlib.import_module(
|
|
f"paddle.distributions.{module_name}"
|
|
)
|
|
|
|
self.assertEqual(
|
|
distribution_module.__file__, distributions_module.__file__
|
|
)
|
|
self.assertTrue(callable(getattr(distribution_module, api_name)))
|
|
self.assertTrue(callable(getattr(distributions_module, api_name)))
|
|
|
|
def assert_normal_usages_equal(self, normal_usages):
|
|
expected = self.get_normal_usage_outputs(normal_usages[0])
|
|
for normal in normal_usages[1:]:
|
|
self.assertEqual(normal.__name__, normal_usages[0].__name__)
|
|
actual = self.get_normal_usage_outputs(normal)
|
|
for actual_value, expected_value in zip(actual, expected):
|
|
self.assert_tensor_equal(actual_value, expected_value)
|
|
|
|
def get_normal_usage_outputs(self, normal):
|
|
value = paddle.to_tensor([0.25, 1.5], dtype="float32")
|
|
dist = normal([0.0, 1.0], [1.0, 2.0], validate_args=False)
|
|
return (
|
|
dist.mean,
|
|
dist.variance,
|
|
dist.entropy(),
|
|
dist.log_prob(value),
|
|
dist.probs(value),
|
|
)
|
|
|
|
def assert_tensor_equal(self, actual, expected):
|
|
self.assertEqual(actual.shape, expected.shape)
|
|
self.assertEqual(actual.dtype, expected.dtype)
|
|
self.assertTrue(bool(paddle.allclose(actual, expected).item()))
|
|
|
|
def assert_api_map(self, api_map):
|
|
for pairs in api_map:
|
|
for alias in pairs[1:]:
|
|
if alias is not None:
|
|
self.assertIs(pairs[0], alias)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|