add alias for paddle.io.DataLoader

Author: algorithm1832

python/paddle/utils/data/__init__.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from .dataloader import (
+    DataLoader,
     default_collate,
     get_worker_info,
 )
@@ -39,6 +40,7 @@
     'ChainDataset',
     'ConcatDataset',
     'Dataset',
+    'DataLoader',
     'IterableDataset',
     'Subset',
     'random_split',

python/paddle/utils/data/dataloader.py

@@ -11,10 +11,78 @@
 # 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.
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING, Any
+
+from paddle.io import DataLoader as PaddleDataLoader
 
 from ._utils.collate import (
     default_collate as default_collate,
 )
 from ._utils.worker import (
     get_worker_info as get_worker_info,
 )
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from paddle.io.dataloader import BatchSampler
+    from paddle.io.dataloader.dataset import Dataset
+    from paddle.io.reader import _CollateFn
+
+
+class DataLoader(PaddleDataLoader):
+    def __init__(
+        self,
+        dataset: Dataset[Any],
+        batch_size: int | None = 1,
+        shuffle: bool | None = None,
+        sampler: BatchSampler | None = None,
+        batch_sampler: BatchSampler | None = None,
+        num_workers: int = 0,
+        collate_fn: _CollateFn | None = None,
+        pin_memory: bool = False,
+        drop_last: bool = False,
+        timeout: float = 0,
+        worker_init_fn: Callable[[int], None] | None = None,
+        multiprocessing_context=None,
+        generator=None,
+        *,
+        prefetch_factor: int | None = None,
+        persistent_workers: bool = False,
+        pin_memory_device: str = "",
+        in_order: bool = True,
+    ) -> None:
+        if (
+            pin_memory is True
+            or multiprocessing_context is not None
+            or generator is not None
+            or prefetch_factor is not None
+            or len(pin_memory_device) > 0
+            or in_order is False
+        ):
+            warnings.warn(
+                "pin_memory, multiprocessing_context, generator, prefetch_factor, pin_memory_device, in_order are currently not supported in DataLoader and will be ignored."
+            )
+
+        if sampler is not None:
+            if batch_sampler is not None:
+                raise ValueError(
+                    "Cannot specify both sampler and batch_sampler"
+                )
+            batch_sampler = sampler
+
+        super().__init__(
+            dataset=dataset,
+            batch_sampler=batch_sampler,
+            batch_size=batch_size,
+            shuffle=shuffle,
+            drop_last=drop_last,
+            collate_fn=collate_fn,
+            num_workers=num_workers,
+            timeout=timeout,
+            worker_init_fn=worker_init_fn,
+            persistent_workers=persistent_workers,
+        )

test/legacy_test/test_api_compatibility_part4.py

@@ -1283,5 +1283,75 @@ def test_dygraph_Compatibility(self):
         paddle.enable_static()
 
 
+class RandomDataset(paddle.utils.data.Dataset):
+    def __init__(self, num_samples):
+        self.num_samples = num_samples
+
+    def __getitem__(self, idx):
+        image = np.random.random([784]).astype('float32')
+        label = np.random.randint(0, 10 - 1, (1,)).astype('int64')
+        return image, label
+
+    def __len__(self):
+        return self.num_samples
+
+
+class TestDataLoaderAPI(unittest.TestCase):
+    def setUp(self):
+        np.random.seed(255)
+        self.batch_num = 4
+        self.batch_size = 8
+        self.dataset = RandomDataset(self.batch_num * self.batch_size)
+        self.batch_sampler = paddle.utils.data.BatchSampler(
+            self.dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            drop_last=True,
+        )
+
+    def iter_loader_data(self, loader):
+        for _ in range(3):
+            for image, label in loader():
+                relu = paddle.nn.functional.relu(image)
+                self.assertEqual(image.shape, [self.batch_size, 784])
+                self.assertEqual(label.shape, [self.batch_size, 1])
+                self.assertEqual(relu.shape, [self.batch_size, 784])
+
+    def test_dygraph_Compatibility(self):
+        paddle.disable_static()
+        # case 1
+        loader = paddle.utils.data.DataLoader(
+            self.dataset,
+            self.batch_size,
+            shuffle=True,
+            num_workers=0,
+            drop_last=True,
+        )
+        self.iter_loader_data(loader)
+        # case 2
+        loader = paddle.utils.data.dataloader.DataLoader(
+            dataset=self.dataset,
+            batch_sampler=self.batch_sampler,
+        )
+        self.iter_loader_data(loader)
+        # case 3
+        loader = paddle.utils.data.DataLoader(
+            dataset=self.dataset,
+            sampler=self.batch_sampler,
+        )
+        self.iter_loader_data(loader)
+        paddle.enable_static()
+
+    def test_error(self):
+        paddle.disable_static()
+        with self.assertRaises(ValueError):
+            loader = paddle.utils.data.dataloader.DataLoader(
+                dataset=self.dataset,
+                sampler=self.batch_sampler,
+                batch_sampler=self.batch_sampler,
+            )
+        paddle.enable_static()
+
+
 if __name__ == "__main__":
     unittest.main()