# Các lớp chính ## DatasetInfo[[datasets.DatasetInfo]] #### datasets.DatasetInfo[[datasets.DatasetInfo]] ```python datasets.DatasetInfo(description: str = , citation: str = , homepage: str = , license: str = , features: typing.Optional[datasets.features.features.Features] = None, post_processed: typing.Optional[datasets.info.PostProcessedInfo] = None, supervised_keys: typing.Optional[datasets.info.SupervisedKeysData] = None, builder_name: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, version: typing.Union[str, datasets.utils.version.Version, NoneType] = None, splits: typing.Optional[datasets.splits.SplitDict] = None, download_checksums: typing.Optional[dict] = None, download_size: typing.Optional[int] = None, post_processing_size: typing.Optional[int] = None, dataset_size: typing.Optional[int] = None, size_in_bytes: typing.Optional[int] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/info.py#L92) **Tham số:** description (`str`) : Mô tả của bộ dữ liệu. citation (`str`) : Trích dẫn BibTeX của bộ dữ liệu. homepage (`str`) : Một URL trỏ đến trang chủ chính thức của bộ dữ liệu. license (`str`) : Giấy phép của bộ dữ liệu. Có thể là tên của giấy phép hoặc một đoạn văn chứa các điều khoản của giấy phép. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng được sử dụng để xác định kiểu của các cột trong bộ dữ liệu. post_processed (`PostProcessedInfo`, *tùy chọn*) : Đã ngừng hỗ trợ. Thông tin về các tài nguyên của một quy trình hậu xử lý có thể có của tập dữ liệu. Ví dụ, nó có thể chứa thông tin về một chỉ mục. supervised_keys (`SupervisedKeysData`, *tùy chọn*) : Chỉ định đặc trưng đầu vào và nhãn cho học có giám sát nếu áp dụng cho bộ dữ liệu (di sản từ TFDS). builder_name (`str`, *tùy chọn*) : Tên của lớp con `GeneratorBasedBuilder` được sử dụng để tạo bộ dữ liệu. Đây cũng là phiên bản snake_case của tên lớp builder bộ dữ liệu. config_name (`str`, *tùy chọn*) : Tên của cấu hình được suy ra từ [BuilderConfig](/docs/datasets/main/vi/package_reference/builder_classes#datasets.BuilderConfig). version (`str` hoặc [Version](/docs/datasets/main/vi/package_reference/builder_classes#datasets.Version), *tùy chọn*) : Phiên bản của bộ dữ liệu. splits (`dict`, *tùy chọn*) : Bản ánh xạ giữa tên split và metadata. download_checksums (`dict`, *tùy chọn*) : Bản ánh xạ giữa URL để tải xuống các checksum của dataset và metadata tương ứng. download_size (`int`, *optional*) : Kích thước của các tệp cần tải xuống để tạo bộ dữ liệu, tính bằng byte. post_processing_size (`int`, *optional*) : Đã ngừng hỗ trợ. Kích thước của bộ dữ liệu tính bằng byte sau khi xử lý hậu kỳ, nếu có. dataset_size (`int`, *optional*) : Tổng kích thước tính bằng byte của các bảng Arrow cho tất cả các phần chia. size_in_bytes (`int`, *tuỳ chọn*) : Tổng kích thước tính bằng byte của tất cả các tệp liên quan đến bộ dữ liệu (tệp đã tải xuống + tệp Arrow). - ****config_kwargs** (các tham số bổ sung) : Các tham số từ khóa được truyền cho [BuilderConfig](/docs/datasets/main/vi/package_reference/builder_classes#datasets.BuilderConfig) và được sử dụng trong [DatasetBuilder](/docs/datasets/main/vi/package_reference/builder_classes#datasets.DatasetBuilder). Thông tin về một bộ dữ liệu. `DatasetInfo` mô tả các tập dữ liệu, bao gồm tên, phiên bản và các đặc trưng. Xem các đối số khởi tạo và thuộc tính để có danh sách đầy đủ. Không phải tất cả các trường đều được biết đến khi khởi tạo và có thể được cập nhật sau đó. #### from_directory[[datasets.DatasetInfo.from_directory]] ```python from_directory(dataset_info_dir: str, storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/info.py#L247) **Tham số:** dataset_info_dir (`str`) : Thư mục chứa tệp metadata. Đây phải là thư mục gốc của một phiên bản dataset cụ thể. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. Tạo [DatasetInfo](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetInfo) từ tệp JSON trong `dataset_info_dir`. Hàm này cập nhật tất cả các trường được tạo động (num_examples, hash, thời gian tạo,...) của [DatasetInfo](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetInfo). Điều này sẽ ghi đè lên tất cả các metadata trước đó. Ví dụ: ```py >>> from datasets import DatasetInfo >>> ds_info = DatasetInfo.from_directory("/path/to/directory/") ``` #### write_to_directory[[datasets.DatasetInfo.write_to_directory]] ```python write_to_directory(dataset_info_dir, pretty_print = False, storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/info.py#L186) **Tham số:** dataset_info_dir (`str`) : Thư mục đích. pretty_print (`bool`, mặc định là `False`) : Nếu `True`, JSON sẽ được in đẹp với mức thụt đầu dòng là 4. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. Viết `DatasetInfo` và giấy phép (nếu có) dưới dạng tệp JSON vào `dataset_info_dir`. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.info.write_to_directory("/path/to/directory/") ``` ## Bộ dữ liệu[[datasets.Dataset]] Lớp cơ sở [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) triển khai một Dataset được hỗ trợ bởi bảng Apache Arrow. #### datasets.Dataset[[datasets.Dataset]] ```python datasets.Dataset(arrow_table: Table, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_table: typing.Optional[datasets.table.Table] = None, fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L709) Một Dataset được hỗ trợ bởi một bảng Arrow. #### add_column[[datasets.Dataset.add_column]] ```python add_column(name: str, column: typing.Union[list, numpy.ndarray], new_fingerprint: typing.Optional[str] = None, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure, NoneType] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6272) **Tham số:** name (`str`) : Tên cột. column (`list` hoặc `np.array`) : Dữ liệu cột cần được thêm vào. feature (`FeatureType` hoặc `None`, mặc định là `None`) : Kiểu dữ liệu của cột. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Thêm cột vào Dataset. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> more_text = ds["text"] >>> ds = ds.add_column(name="text_2", column=more_text) >>> ds Dataset({ features: ['text', 'label', 'text_2'], num_rows: 1066 }) ``` #### add_item[[datasets.Dataset.add_item]] ```python add_item(item: dict, new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6534) **Tham số:** item (`dict`) : Dữ liệu mục cần được thêm vào. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Thêm mục vào Dataset. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> new_review = {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'} >>> ds = ds.add_item(new_review) >>> ds[-1] {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'} ``` #### from_file[[datasets.Dataset.from_file]] ```python from_file(filename: str, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_filename: typing.Optional[str] = None, in_memory: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L792) **Tham số:** filename (`str`) : Tên tệp của bộ dữ liệu. info (`DatasetInfo`, *tùy chọn*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, *tùy chọn*) : Tên của phần chia bộ dữ liệu. indices_filename (`str`, *tùy chọn*) : Tên tệp của các chỉ mục. in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo một Dataset dựa trên bảng Arrow tại filename. #### from_buffer[[datasets.Dataset.from_buffer]] ```python from_buffer(buffer: Buffer, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_buffer: typing.Optional[pyarrow.lib.Buffer] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L832) **Tham số:** buffer (`pyarrow.Buffer`) : bộ đệm Arrow. info (`DatasetInfo`, *tùy chọn*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, *tùy chọn*) : Tên của phần chia bộ dữ liệu. indices_buffer (`pyarrow.Buffer`, *tuỳ chọn*) : Bộ đệm chỉ mục Arrow. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo một Dataset được hỗ trợ bởi bộ đệm Arrow. #### from_pandas[[datasets.Dataset.from_pandas]] ```python from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L864) **Tham số:** df (`pandas.DataFrame`) : Dataframe chứa bộ dữ liệu. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. info (`DatasetInfo`, *tùy chọn*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, *tùy chọn*) : Tên của phần chia bộ dữ liệu. preserve_index (`bool`, *tuỳ chọn*) : Có lưu trữ chỉ số dưới dạng một cột bổ sung trong Dataset kết quả hay không. Giá trị mặc định `None` sẽ lưu trữ chỉ số dưới dạng một cột, ngoại trừ `RangeIndex` chỉ được lưu trữ dưới dạng metadata. Sử dụng `preserve_index=True` để buộc lưu trữ dưới dạng một cột. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Chuyển đổi `pandas.DataFrame` thành `pyarrow.Table` để tạo một [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset). Các kiểu cột trong Arrow Table kết quả được suy ra từ dtypes của `pandas.Series` trong DataFrame. Đối với các Series không phải object, NumPy dtype được chuyển đổi sang tương đương Arrow của nó. Đối với `object`, chúng ta cần đoán kiểu dữ liệu bằng cách xem xét các đối tượng Python trong Series này. Lưu ý rằng các Series có dtype `object` không chứa đủ thông tin để luôn dẫn đến một kiểu Arrow có ý nghĩa. Trong trường hợp không thể suy luận được kiểu, ví dụ vì DataFrame có độ dài 0 hoặc Series chỉ chứa các đối tượng `None/nan`, kiểu sẽ được đặt thành `null`. Có thể tránh hành vi này bằng cách xây dựng các feature rõ ràng và truyền chúng vào hàm này. Quan trọng: một dataset được tạo bằng from_pandas() nằm trong bộ nhớ và do đó không có thư mục cache liên quan. Điều này có thể thay đổi trong tương lai, nhưng trong thời gian chờ đợi, nếu bạn muốn giảm mức sử dụng bộ nhớ, bạn nên ghi lại nó trên đĩa và tải lại bằng cách sử dụng ví dụ save_to_disk / load_from_disk. Ví dụ: ```py >>> ds = Dataset.from_pandas(df) ``` #### from_dict[[datasets.Dataset.from_dict]] ```python from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L982) **Tham số:** mapping (`Mapping`) : Ánh xạ các chuỗi sang các mảng hoặc danh sách Python. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. info (`DatasetInfo`, *tùy chọn*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, *tùy chọn*) : Tên của phần chia bộ dữ liệu. on_mixed_types (`Literal["use_json"]`, *tùy chọn*, mặc định là `None`) : Nếu là "use_json", hãy sử dụng kiểu Json() cho các trường có kiểu dữ liệu hỗn hợp, tức là các trường không có cấu trúc chứa dữ liệu không có schema được định nghĩa trước. Trong trường hợp này, một trường có kiểu hỗn hợp sẽ được đặt thành Json(). Điều này cho phép nạp các danh sách chứa hỗn hợp chuỗi/số nguyên/số thực, chẳng hạn, hoặc các từ điển có kiểu giá trị tùy ý. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Chuyển đổi `dict` thành `pyarrow.Table` để tạo một [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset). Quan trọng: một dataset được tạo bằng from_dict() sẽ nằm trong bộ nhớ và do đó không có thư mục cache liên quan. Điều này có thể thay đổi trong tương lai, nhưng trong thời gian chờ đợi, nếu bạn muốn giảm mức sử dụng bộ nhớ, bạn nên ghi lại nó xuống đĩa và tải lại bằng cách sử dụng ví dụ save_to_disk / load_from_disk. Ví dụ: Tạo một Dataset từ một từ điển chứa một danh sách cho mỗi cột: ```py >>> ds = Dataset.from_dict({"text": ["hello there !", "general kenobi !"]}) ``` Truyền features để đặt kiểu cho các cột, ví dụ với một tập dữ liệu ảnh: ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_dict({"image": ["path/to/image.png"]}, features=features) ``` Datasets được xây dựng dựa trên Arrow, một định dạng cột, do đó chúng yêu cầu mỗi ví dụ phải có cùng kiểu và các kiểu con, và các từ điển phải có cùng các khóa và kiểu giá trị. Việc tải một dataset sẽ gây ra lỗi khi các trường có kiểu không khớp, và sẽ điền các trường bị thiếu trong các từ điển bằng None để đảm bảo tất cả các từ điển đều có cùng các khóa và kiểu giá trị. Để tránh điều này và cho phép các kiểu dữ liệu hỗn hợp mà không gặp lỗi, bạn có thể sử dụng `on_mixed_types="use_json"` hoặc chỉ định `features=` với kiểu [Json](/docs/datasets/main/vi/package_reference/loading_methods#datasets.Json): ```py >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}) Traceback (most recent call last): ... File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64 >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, on_mixed_types="use_json") >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] >>> features = Features({"a": Json()}) >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, features=features) >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] ``` Điều này cũng hữu ích cho các danh sách từ điển có các khóa và giá trị tùy ý, để tránh điền các trường thiếu bằng None: ```py >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}) >>> ds.features {'a': List({'b': Value('int64'), 'c': Value('int64')})} >>> list(ds["a"]) [[{'b': 0, 'c': None}, {'b': None, 'c': 0}]] # missing fields are filled with None >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features) >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK ``` Một ví dụ khác với dữ liệu gọi công cụ: ```py >>> messages = [ ... {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."}, ... {"role": "assistant", "tool_calls": [ ... {"type": "function", "function": { ... "name": "control_light", ... "arguments": {"room": "living room", "state": "on"} ... }}, ... {"type": "function", "function": { ... "name": "play_music", ... "arguments": {"playlist": "electronic"} # mixed-type here since keys ["playlist"] and ["room", "state"] are different ... }}] ... }, ... {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."}, ... {"role": "tool", "name": "play_music", "content": "The music is now playing."}, ... {"role": "assistant", "content": "Done!"} ... ] >>> ds = Dataset.from_dict({"messages": [messages]}, on_mixed_types="use_json") >>> ds.features {'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})} >>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"] {"room": "living room", "state": "on"} ``` #### from_list[[datasets.Dataset.from_list]] ```python from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1148) **Tham số:** mapping (`List[dict]`) : Một danh sách các ánh xạ từ chuỗi đến giá trị hàng. features (`Features`, tùy chọn) : Các đặc trưng của tập dữ liệu. info (`DatasetInfo`, tùy chọn) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, tùy chọn) : Tên của phần chia bộ dữ liệu. on_mixed_types (`Literal["use_json"]`, *tùy chọn*, mặc định là `None`) : Nếu là "use_json", hãy sử dụng kiểu Json() cho các trường có kiểu dữ liệu hỗn hợp, tức là các trường không có cấu trúc chứa dữ liệu không có schema được định nghĩa trước. Trong trường hợp này, một trường có kiểu hỗn hợp sẽ được đặt thành Json(). Điều này cho phép nạp các danh sách chứa hỗn hợp chuỗi/số nguyên/số thực, chẳng hạn, hoặc các từ điển có kiểu giá trị tùy ý. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Chuyển đổi một danh sách các dict thành `pyarrow.Table` để tạo một [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset)` Lưu ý rằng các khóa của mục đầu tiên sẽ được sử dụng để xác định các cột của bộ dữ liệu, bất kể giá trị nào được truyền vào features. Quan trọng: một dataset được tạo bằng from_list() sẽ nằm trong bộ nhớ và do đó không có thư mục cache liên quan. Điều này có thể thay đổi trong tương lai, nhưng trong thời gian chờ đợi, nếu bạn muốn giảm mức sử dụng bộ nhớ, bạn nên ghi lại nó xuống đĩa và tải lại bằng cách sử dụng ví dụ save_to_disk / load_from_disk. Ví dụ: Tạo một Dataset từ danh sách chứa các ví dụ: ```py >>> ds = Dataset.from_list([{"text": "hello there !"}, {"text": "general kenobi !"}]}) ``` Truyền features để đặt kiểu cho các cột, ví dụ với một tập dữ liệu ảnh: ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_list([{"image": "path/to/image.png"}], features=features) ``` Datasets được xây dựng dựa trên Arrow, một định dạng cột, do đó chúng yêu cầu mỗi ví dụ phải có cùng kiểu và các kiểu con, và các từ điển phải có cùng các khóa và kiểu giá trị. Việc tải một dataset sẽ gây ra lỗi khi các trường có kiểu không khớp, và sẽ điền các trường bị thiếu trong các từ điển bằng None để đảm bảo tất cả các từ điển đều có cùng các khóa và kiểu giá trị. Để tránh điều này và cho phép các kiểu dữ liệu hỗn hợp mà không gặp lỗi, bạn có thể sử dụng `on_mixed_types="use_json"` hoặc chỉ định `features=` với kiểu [Json](/docs/datasets/main/vi/package_reference/loading_methods#datasets.Json): ```py >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}]) Traceback (most recent call last): ... File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64 >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], on_mixed_types="use_json") >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] >>> features = Features({"a": Json()}) >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], features=features) >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] ``` Điều này cũng hữu ích cho các danh sách từ điển có các khóa và giá trị tùy ý, để tránh điền các trường thiếu bằng None: ```py >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}]) >>> ds.features {'a': List({'b': Value('int64'), 'c': Value('int64')})} >>> list(ds["a"]) [[{'b': 0, 'c': None}, {'b': None, 'c': 0}]] # missing fields are filled with None >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], features=features) >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK ``` Một ví dụ khác với dữ liệu gọi công cụ: ```py >>> messages = [ ... {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."}, ... {"role": "assistant", "tool_calls": [ ... {"type": "function", "function": { ... "name": "control_light", ... "arguments": {"room": "living room", "state": "on"} ... }}, ... {"type": "function", "function": { ... "name": "play_music", ... "arguments": {"playlist": "electronic"} # mixed-type here since keys ["playlist"] and ["room", "state"] are different ... }}] ... }, ... {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."}, ... {"role": "tool", "name": "play_music", "content": "The music is now playing."}, ... {"role": "assistant", "content": "Done!"} ... ] >>> ds = Dataset.from_list([{"messages": messages}], on_mixed_types="use_json") >>> ds.features {'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})} >>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"] {"room": "living room", "state": "on"} ``` #### from_generator[[datasets.Dataset.from_generator]] ```python from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, gen_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, split: NamedSplit = NamedSplit('train'), fingerprint: typing.Optional[str] = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1337) **Tham số:** generator ( --`Callable`): Một hàm generator `yields` các ví dụ. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. gen_kwargs(`dict`, *tùy chọn*) : Các đối số dạng từ khóa để truyền cho callable `generator`. Bạn có thể định nghĩa một tập dữ liệu phân mảnh bằng cách truyền danh sách các phân mảnh trong `gen_kwargs` và đặt `num_proc` lớn hơn 1. num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình khi tải xuống và tạo bộ dữ liệu cục bộ. Điều này hữu ích nếu bộ dữ liệu được tạo từ nhiều tệp. Xử lý đa tiến trình bị vô hiệu hóa theo mặc định. Nếu `num_proc` lớn hơn một, thì tất cả các giá trị danh sách trong `gen_kwargs` phải có cùng độ dài. Các giá trị này sẽ được chia cho các lần gọi bộ tạo. Số lượng shard sẽ là giá trị nhỏ nhất giữa danh sách ngắn nhất trong `gen_kwargs` và `num_proc`. split ([NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit), mặc định là `Split.TRAIN`) : Tên split được gán cho tập dữ liệu. fingerprint (`str`, *tùy chọn*) : Fingerprint sẽ được dùng để tạo dataset ID. Mặc định, `fingerprint` được tạo bằng cách băm (hash) hàm generator và tất cả các args, điều này có thể chậm nếu nó sử dụng các đối tượng lớn như mô hình AI. - ****kwargs** (các tham số từ khóa bổ sung) : Các tham số từ khóa được truyền tới :`GeneratorConfig`. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo một Dataset từ một generator. Tải dữ liệu từ trình tạo, lưu trữ tạm dữ liệu trên đĩa ở định dạng Arrow và trả về Dataset từ dữ liệu Arrow được ánh xạ bộ nhớ trên đĩa. Ví dụ: ```py >>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = Dataset.from_generator(gen) ``` ```py >>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = Dataset.from_generator(gen, gen_kwargs={"shards": shards}) ``` #### data[[datasets.Dataset.data]] ```python data() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2098) Bảng Apache Arrow hỗ trợ cho bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.data MemoryMappedTable text: string label: int64 ---- text: [["compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .","the soundtrack alone is worth the price of admission .","rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .","beneath the film's obvious determination to shock at any cost lies considerable skill and determination , backed by sheer nerve .","bielinsky is a filmmaker of impressive talent .","so beautifully acted and directed , it's clear that washington most certainly has a new career ahead of him if he so chooses .","a visual spectacle full of stunning images and effects .","a gentle and engrossing character study .","it's enough to watch huppert scheming , with her small , intelligent eyes as steady as any noir villain , and to enjoy the perfectly pitched web of tension that chabrol spins .","an engrossing portrait of uncompromising artists trying to create something original against the backdrop of a corporate music industry that only seems to care about the bottom line .",...,"ultimately , jane learns her place as a girl , softens up and loses some of the intensity that made her an interesting character to begin with .","ah-nuld's action hero days might be over .","it's clear why deuces wild , which was shot two years ago , has been gathering dust on mgm's shelf .","feels like nothing quite so much as a middle-aged moviemaker's attempt to surround himself with beautiful , half-naked women .","when the precise nature of matthew's predicament finally comes into sharp focus , the revelation fails to justify the build-up .","this picture is murder by numbers , and as easy to be bored by as your abc's , despite a few whopping shootouts .","hilarious musical comedy though stymied by accents thick as mud .","if you are into splatter movies , then you will probably have a reasonably good time with the salton sea .","a dull , simple-minded and stereotypical tale of drugs , death and mind-numbing indifference on the inner-city streets .","the feature-length stretch . . . strains the show's concept ."]] label: [[1,1,1,1,1,1,1,1,1,1,...,0,0,0,0,0,0,0,0,0,0]] ``` #### cache_files[[datasets.Dataset.cache_files]] ```python cache_files() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2118) Các tệp cache chứa bảng Apache Arrow hỗ trợ cho bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.cache_files [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}] ``` #### num_columns[[datasets.Dataset.num_columns]] ```python num_columns() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2136) Số cột trong bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.num_columns 2 ``` #### num_rows[[datasets.Dataset.num_rows]] ```python num_rows() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2151) Số dòng trong bộ dữ liệu (giống như [Dataset.__len__()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.__len__)). Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.num_rows 1066 ``` #### column_names[[datasets.Dataset.column_names]] ```python column_names() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2168) Tên của các cột trong bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.column_names ['text', 'label'] ``` #### shape[[datasets.Dataset.shape]] ```python shape() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2183) Hình dạng của bộ dữ liệu (số cột, số hàng). Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.shape (1066, 2) ``` #### unique[[datasets.Dataset.unique]] ```python unique(column: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2200) **Tham số:** column (`str`) : Tên cột (liệt kê tất cả tên cột bằng [column_names](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.column_names)). **Trả về:** `list` Danh sách các phần tử duy nhất trong cột được cho. Trả về danh sách các phần tử duy nhất trong một cột. Điều này được triển khai trong backend cấp thấp và do đó, rất nhanh. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.unique('label') [1, 0] ``` #### flatten[[datasets.Dataset.flatten]] ```python flatten(new_fingerprint: typing.Optional[str] = None, max_depth = 16) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2306) **Tham số:** new_fingerprint (`str`, *tùy chọn*) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Một bản sao của bộ dữ liệu với các cột đã được làm phẳng. Phẳng hóa bảng. Mỗi cột có kiểu struct được phẳng hóa thành một cột cho mỗi trường của struct. Các cột khác được giữ nguyên. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad", split="train") >>> ds.features {'id': Value('string'), 'title': Value('string'), 'context': Value('string'), 'question': Value('string'), 'answers': {'text': List(Value('string')), 'answer_start': List(Value('int32'))}} >>> ds = ds.flatten() >>> ds Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) ``` #### cast[[datasets.Dataset.cast]] ```python cast(features: Features, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, num_proc: typing.Optional[int] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2353) **Tham số:** features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features)) : Các tính năng mới để chuyển đổi (cast) dataset sang. Tên của các trường trong features phải khớp với tên cột hiện tại. Kiểu dữ liệu cũng phải có thể chuyển đổi từ kiểu này sang kiểu khác. Đối với các phép chuyển đổi không đơn giản, ví dụ `str` <-> `ClassLabel`, bạn nên sử dụng [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.map) để cập nhật Dataset. batch_size (`int`, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho cast. Nếu `batch_size <= 0` hoặc `batch_size == None` thì cung cấp toàn bộ dataset như một batch duy nhất cho cast. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. load_from_cache_file (`bool`, mặc định là `True` nếu bộ nhớ đệm được bật) : Nếu có thể xác định một tệp bộ nhớ đệm lưu trữ kết quả tính toán hiện tại từ `function`, hãy sử dụng tệp đó thay vì tính toán lại. cache_file_name (`str`, *tùy chọn*, mặc định là `None`) : Cung cấp tên của một đường dẫn cho tệp cache. Nó được sử dụng để lưu trữ kết quả của phép tính thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.map). num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình cho đa tiến trình. Mặc định không sử dụng đa tiến trình. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Một bản sao của bộ dữ liệu với các đặc trưng đã được chuyển đổi kiểu. Đổ khuôn (cast) bộ dữ liệu sang một tập tính năng mới. Ví dụ: ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds.features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.Dataset.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure], new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2437) **Tham số:** column (`str`) : Tên cột. feature (`FeatureType`) : Đặc trưng đích. new_fingerprint (`str`, *tùy chọn*) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Đổ cột sang tính năng để giải mã. Ví dụ: ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.Dataset.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2480) **Tham số:** column_names (`Union[str, List[str]]`) : Tên của cột (các cột) cần xóa. new_fingerprint (`str`, *tùy chọn*) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Một bản sao của đối tượng bộ dữ liệu không bao gồm các cột cần xóa. Xóa một hoặc nhiều cột trong bộ dữ liệu và các đặc trưng liên quan đến chúng. Bạn cũng có thể xóa một cột bằng cách sử dụng [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.map) với `remove_columns` nhưng phương pháp hiện tại không sao chép dữ liệu của các cột còn lại nên nhanh hơn. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.remove_columns('label') Dataset({ features: ['text'], num_rows: 1066 }) >>> ds = ds.remove_columns(column_names=ds.column_names) # Removing all the columns returns an empty dataset with the `num_rows` property set to 0 Dataset({ features: [], num_rows: 0 }) ``` #### rename_column[[datasets.Dataset.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str, new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2535) **Tham số:** original_column_name (`str`) : Tên của cột cần đổi tên. new_column_name (`str`) : Tên mới cho cột. new_fingerprint (`str`, *tùy chọn*) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Một bản sao của bộ dữ liệu với một cột đã được đổi tên. Đổi tên một cột trong bộ dữ liệu, và di chuyển các đặc trưng liên quan đến cột gốc sang dưới tên cột mới. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.rename_column('label', 'label_new') Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) ``` #### rename_columns[[datasets.Dataset.rename_columns]] ```python rename_columns(column_mapping: dict, new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2601) **Tham số:** column_mapping (`Dict[str, str]`) : Bản ánh xạ từ các cột cần đổi tên sang tên mới của chúng new_fingerprint (`str`, *tùy chọn*) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Một bản sao của bộ dữ liệu với các cột đã được đổi tên Đổi tên một số cột trong bộ dữ liệu, và di chuyển các đặc trưng liên quan đến các cột gốc sang dưới tên cột mới. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) ``` #### select_columns[[datasets.Dataset.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2668) **Tham số:** column_names (`Union[str, List[str]]`) : Tên của cột (các cột) cần giữ lại. new_fingerprint (`str`, *tùy chọn*) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Một bản sao của đối tượng tập dữ liệu chỉ bao gồm các cột được chọn. Chọn một hoặc nhiều cột trong bộ dữ liệu và các đặc trưng liên quan đến chúng. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.select_columns(['text']) >>> ds Dataset({ features: ['text'], num_rows: 1066 }) ``` #### class_encode_column[[datasets.Dataset.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2231) **Tham số:** column (`str`) : Tên của cột cần chuyển đổi (liệt kê tất cả tên cột bằng [column_names](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.column_names)) include_nulls (`bool`, mặc định là `False`) : Có bao gồm các giá trị null trong nhãn lớp hay không. Nếu `True`, các giá trị null sẽ được mã hóa thành nhãn lớp `"None"`. Đổ cột đã cho sang [ClassLabel](/docs/datasets/main/vi/package_reference/main_classes#datasets.ClassLabel) và cập nhật bảng. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("google/boolq", split="validation") >>> ds.features {'answer': Value('bool'), 'passage': Value('string'), 'question': Value('string')} >>> ds = ds.class_encode_column('answer') >>> ds.features {'answer': ClassLabel(num_classes=2, names=['False', 'True']), 'passage': Value('string'), 'question': Value('string')} ``` #### __len__[[datasets.Dataset.__len__]] ```python __len__() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2724) Số dòng trong bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.__len__ ``` #### __iter__[[datasets.Dataset.__iter__]] ```python __iter__() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2741) Lặp qua các ví dụ. Nếu một định dạng được đặt bằng [Dataset.set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format), các hàng sẽ được trả về với định dạng đã chọn. #### iter[[datasets.Dataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2770) **Tham số:** batch_size (`int`) : kích thước của mỗi batch để tạo ra. drop_last_batch (`bool`, mặc định *False*) : Có nên loại bỏ một batch cuối nhỏ hơn batch_size hay không Lặp qua các lô có kích thước *batch_size*. Nếu một định dạng được đặt bằng [*~datasets.Dataset.set_format*], các hàng sẽ được trả về với định dạng đã chọn. #### formatted_as[[datasets.Dataset.formatted_as]] ```python formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2814) **Tham số:** type (`str`, *tùy chọn*) : Kiểu đầu ra được chọn trong `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` có nghĩa là `__getitem__`` trả về các đối tượng python (mặc định). columns (`List[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. `None` có nghĩa là `__getitem__` trả về tất cả các cột (mặc định). output_all_columns (`bool`, mặc định là `False`) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). - ****format_kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền cho hàm chuyển đổi như `np.array`, `torch.tensor` hoặc `tensorflow.ragged.constant`. Được sử dụng trong một câu lệnh `with`. Đặt định dạng trả về của `__getitem__` (kiểu và các cột). #### set_format[[datasets.Dataset.set_format]] ```python set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2846) **Tham số:** type (`str`, *tùy chọn*) : Kiểu đầu ra được chọn trong `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` có nghĩa là `__getitem__` trả về các đối tượng python (mặc định). columns (`List[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. `None` có nghĩa là `__getitem__` trả về tất cả các cột (mặc định). output_all_columns (`bool`, mặc định là `False`) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). - ****format_kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền cho hàm chuyển đổi như `np.array`, `torch.tensor` hoặc `tensorflow.ragged.constant`. Định dạng trả về của `__getitem__` (kiểu và các cột). Việc định dạng dữ liệu được áp dụng theo thời gian thực. Định dạng `type` (ví dụ "numpy") được dùng để định dạng các batch khi sử dụng `__getitem__`. Bạn cũng có thể sử dụng các transform tùy chỉnh để định dạng bằng cách dùng [set_transform()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_transform). Có thể gọi [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.map) sau khi gọi `set_format`. Vì `map` có thể thêm các cột mới, nên danh sách các cột đã định dạng được cập nhật. Trong trường hợp này, nếu bạn áp dụng `map` lên một dataset để thêm một cột mới, thì cột này sẽ được định dạng như sau: ``` new formatted columns = (all columns - previously unformatted columns) ``` Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['text', 'label']) >>> ds.format {'type': 'numpy', 'format_kwargs': {}, 'columns': ['text', 'label'], 'output_all_columns': False} ``` #### set_transform[[datasets.Dataset.set_transform]] ```python set_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2954) **Tham số:** transform (`Callable`, *tùy chọn*) : Biến đổi định dạng do người dùng định nghĩa, thay thế định dạng được định nghĩa bởi [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format). Một hàm định dạng là một callable nhận một batch (dưới dạng `dict`) làm đầu vào và trả về một batch. Hàm này được áp dụng ngay trước khi trả về các đối tượng trong `__getitem__`. columns (`List[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. Nếu được chỉ định, thì lô đầu vào của phép biến đổi chỉ chứa các cột đó. output_all_columns (`bool`, mặc định là `False`) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). Nếu đặt thành True, các cột chưa được định dạng khác sẽ được giữ lại cùng với kết quả của phép biến đổi. Định dạng trả về của `__getitem__` bằng cách sử dụng transform này. Transform được áp dụng trực tiếp trên các batch khi `__getitem__` được gọi. Giống như [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format), điều này có thể được đặt lại bằng [reset_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.reset_format). Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') >>> def encode(batch): ... return tokenizer(batch['text'], padding=True, truncation=True, return_tensors='pt') >>> ds.set_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 29353, 2135, 15102, 1996, 9428, 20868, 2890, 8663, 6895, 20470, 2571, 3663, 2090, 4603, 3017, 3008, 1998, 2037, 24211, 5637, 1998, 11690, 2336, 1012, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### reset_format[[datasets.Dataset.reset_format]] ```python reset_format() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2925) Đặt lại định dạng trả về của `__getitem__` thành các đối tượng python và tất cả các cột. Tương tự như `self.set_format()` Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds.format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} ``` #### with_format[[datasets.Dataset.with_format]] ```python with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2997) **Tham số:** type (`str`, *tùy chọn*) : Kiểu đầu ra được chọn trong `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` có nghĩa là `__getitem__` trả về các đối tượng python (mặc định). columns (`List[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. `None` có nghĩa là `__getitem__` trả về tất cả các cột (mặc định). output_all_columns (`bool`, mặc định là `False`) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). - ****format_kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền cho hàm chuyển đổi như `np.array`, `torch.tensor` hoặc `tensorflow.ragged.constant`. Định dạng trả về của `__getitem__` (kiểu và các cột). Việc định dạng dữ liệu được áp dụng theo thời gian thực. Định dạng `type` (ví dụ "numpy") được dùng để định dạng các lô dữ liệu khi sử dụng `__getitem__`. Bạn cũng có thể sử dụng các transform tùy chỉnh để định dạng bằng [with_transform()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.with_transform). Ngược lại với [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format), `with_format` trả về một đối tượng [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) mới. Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format("torch") >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'torch'} >>> ds[0] {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### with_transform[[datasets.Dataset.with_transform]] ```python with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3068) **Tham số:** transform (`Callable`, `optional`) : Biến đổi định dạng do người dùng định nghĩa, thay thế định dạng được định nghĩa bởi [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format). Một hàm định dạng là một callable nhận một batch (dưới dạng `dict`) làm đầu vào và trả về một batch. Hàm này được áp dụng ngay trước khi trả về các đối tượng trong `__getitem__`. columns (`List[str]`, `optional`) : Các cột cần định dạng trong đầu ra. Nếu được chỉ định, thì batch đầu vào của transform chỉ chứa các cột đó. output_all_columns (`bool`, mặc định là `False`) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). Nếu đặt thành `True`, các cột chưa được định dạng khác sẽ được giữ lại cùng với kết quả của phép biến đổi. Định dạng trả về của `__getitem__` bằng cách sử dụng transform này. Transform được áp dụng trực tiếp trên các batch khi `__getitem__` được gọi. Giống như [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format), điều này có thể được đặt lại bằng [reset_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.reset_format). Ngược lại với [set_transform()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_transform), `with_transform` trả về một đối tượng [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) mới. Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example["text"], padding=True, truncation=True, return_tensors='pt') >>> ds = ds.with_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### __getitem__[[datasets.Dataset.__getitem__]] ```python __getitem__(key) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3144) Có thể được sử dụng để chỉ định các cột (theo tên chuỗi) hoặc các hàng (theo chỉ mục nguyên hoặc khả lặp của các chỉ mục hoặc giá trị bool). #### cleanup_cache_files[[datasets.Dataset.cleanup_cache_files]] ```python cleanup_cache_files() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3157) **Trả về:** `int` Số lượng tệp đã bị xóa. Dọn dẹp tất cả các tệp cache trong thư mục cache của bộ dữ liệu, ngoại trừ tệp cache đang được sử dụng (nếu có). Hãy cẩn thận khi chạy lệnh này để đảm bảo không có tiến trình nào khác đang sử dụng các tệp cache khác. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.cleanup_cache_files() 10 ``` #### map[[datasets.Dataset.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = 'use_json') ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3204) **Tham số:** function (`Callable`) : Hàm có một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> Dict[str, Any]` nếu `batched=False` và `with_indices=False` và `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]` nếu `batched=False` và `with_indices=True` và/hoặc `with_rank=True` (mỗi tham số này thêm một đối số) - `function(batch: Dict[str, List]) -> Dict[str, List]` nếu `batched=True` và `with_indices=False` và `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]` nếu `batched=True` và `with_indices=True` và/hoặc `with_rank=True` (mỗi tham số này thêm một đối số) Đối với cách sử dụng nâng cao, hàm cũng có thể trả về một `pyarrow.Table`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song. Hơn nữa, nếu hàm của bạn không trả về gì (`None`), thì `map` sẽ chạy hàm của bạn và trả về tập dữ liệu không thay đổi. Nếu không cung cấp hàm, mặc định dùng hàm đồng nhất: `lambda x: x`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx[, rank]): ...`. with_rank (`bool`, mặc định là `False`) : Cung cấp thứ tự tiến trình cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example[, idx], rank): ...`. input_columns (`Optional[Union[str, List[str]]]`, mặc định là `None`) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một `dict` ánh xạ đến tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function`. batch_size (`int`, *tuỳ chọn*, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched=True`. Nếu `batch_size <= 0` hoặc `batch_size == None`, cung cấp toàn bộ tập dữ liệu như một batch duy nhất cho `function`. drop_last_batch (`bool`, mặc định là `False`) : Xác định xem một batch cuối nhỏ hơn batch_size có nên bị loại bỏ thay vì được xử lý bởi hàm hay không. remove_columns (`Optional[Union[str, List[str]]]`, mặc định là `None`) : Loại bỏ một tập các cột khi thực hiện ánh xạ. Các cột sẽ bị loại bỏ trước khi cập nhật các ví dụ bằng kết quả đầu ra của `function`, tức là nếu `function` thêm các cột có tên nằm trong `remove_columns`, các cột này sẽ được giữ lại. keep_in_memory (`bool`, mặc định là `False`) : Giữ bộ dữ liệu trong bộ nhớ thay vì ghi nó vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ kết quả tính toán hiện tại của `function`, hãy sử dụng tệp đó thay vì tính toán lại. cache_file_name (`str`, *tùy chọn*, mặc định là `None`) : Cung cấp tên của một đường dẫn cho tệp cache. Nó được sử dụng để lưu trữ kết quả của phép tính thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. features (`Optional[datasets.Features]`, mặc định là `None`) : Sử dụng một Features cụ thể để lưu trữ tệp cache thay vì tệp được tạo tự động. disable_nullable (`bool`, mặc định là `False`) : Không cho phép các giá trị null trong bảng. fn_kwargs (`Dict`, *tùy chọn*, mặc định là `None`) : Các đối số từ khóa để truyền cho `function`. num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình cần sử dụng cho đa tiến trình. - Nếu là `None` hoặc `0`, sẽ không sử dụng đa tiến trình và thao tác được thực thi trong tiến trình chính. - Nếu lớn hơn `1`, một hoặc nhiều tiến trình worker sẽ được sử dụng để xử lý dữ liệu song song. Lưu ý: Hàm được truyền vào `map()` phải có thể picklable để đa tiến trình hoạt động chính xác (tức là nên ưu tiên các hàm được định nghĩa ở cấp trên cùng của một module, không nên đặt bên trong một hàm hoặc lớp khác). suffix_template (`str`): Nếu `cache_file_name` được chỉ định, hậu tố này sẽ được thêm vào cuối tên gốc của mỗi tệp. Mặc định là `"_{rank:05d}_of_{num_proc:05d}"`. Ví dụ, nếu `cache_file_name` là "processed.arrow", thì với `rank=1` và `num_proc=4`, tệp kết quả sẽ là `"processed_00001_of_00004.arrow"` với hậu tố mặc định. new_fingerprint (`str`, *tùy chọn*, mặc định là `None`) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu là `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. desc (`str`, *tùy chọn*, mặc định là `None`) : Mô tả có ý nghĩa để hiển thị cùng với thanh tiến trình trong khi ánh xạ các ví dụ. try_original_type (`Optional[bool]`, mặc định là `True`) : Cố gắng giữ nguyên kiểu dữ liệu của các cột gốc (ví dụ: int32 -> int32). Đặt thành False nếu bạn muốn luôn suy luận các kiểu dữ liệu mới. on_mixed_types (`Literal["use_json"]`, *tùy chọn*, mặc định là `None`) : Nếu là "use_json", hãy sử dụng kiểu Json() cho các trường có kiểu dữ liệu hỗn hợp, tức là các trường không có cấu trúc chứa dữ liệu không có schema được định nghĩa trước. Trong trường hợp này, một trường có kiểu hỗn hợp sẽ được đặt thành Json(). Điều này cho phép nạp các danh sách chứa hỗn hợp chuỗi/số nguyên/số thực, chẳng hạn, hoặc các từ điển có kiểu giá trị tùy ý. Áp dụng một hàm cho tất cả các ví dụ trong bảng (riêng lẻ hoặc theo lô) và cập nhật bảng. Nếu hàm của bạn trả về một cột đã tồn tại, nó sẽ ghi đè lên cột đó. Bạn có thể chỉ định xem hàm có nên được xử lý theo lô (batched) hay không bằng tham số `batched`: - Nếu `False`, thì hàm nhận vào 1 ví dụ và phải trả về 1 ví dụ. Một ví dụ là một từ điển, ví dụ `{"text": "Hello there !"}`. - Nếu `True` và `batch_size` là 1, thì hàm nhận vào một batch gồm 1 ví dụ và có thể trả về một batch gồm 1 hoặc nhiều hơn các ví dụ. Một batch là một từ điển, ví dụ một batch gồm 1 ví dụ là `{"text": ["Hello there !"]}`. - Nếu `True` và `batch_size` là `n > 1`, thì hàm nhận vào một batch gồm `n` ví dụ và có thể trả về một batch gồm `n` ví dụ, hoặc một số lượng ví dụ bất kỳ. Lưu ý rằng batch cuối cùng có thể có ít hơn `n` ví dụ. Một batch là một từ điển, ví dụ một batch gồm `n` ví dụ là `{"text": ["Hello there !"] * n}`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song, với tối đa một nghìn cuộc gọi đồng thời. Khuyến nghị sử dụng `asyncio.Semaphore` trong hàm của bạn nếu bạn muốn đặt số lượng tối đa các thao tác có thể chạy cùng lúc. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds[0:3]["text"] ['Review: compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'Review: the soundtrack alone is worth the price of admission .', 'Review: rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4) ``` #### lọc[[datasets.Dataset.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4137) **Tham số:** function (`Callable`) : Callable có một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> bool` nếu `batched=False` và `with_indices=False` và `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` nếu `batched=False` và `with_indices=True` và/hoặc `with_rank=True` (mỗi tham số này thêm một đối số) - `function(batch: Dict[str, List]) -> List[bool]` nếu `batched=True` và `with_indices=False` và `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> List[bool]` nếu `batched=True` và `with_indices=True` và/hoặc `with_rank=True` (mỗi tham số này thêm một đối số) Nếu hàm là bất đồng bộ, thì `filter` sẽ chạy hàm của bạn song song. Nếu không cung cấp hàm, mặc định là hàm luôn trả về `True`: `lambda x: True`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx[, rank]): ...`. with_rank (`bool`, mặc định là `False`) : Cung cấp thứ tự tiến trình cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example[, idx], rank): ...`. input_columns (`str` hoặc `List[str]`, *tùy chọn*) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một `dict` ánh xạ tới tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function`. batch_size (`int`, *tuỳ chọn*, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched = True`. Nếu `batched = False`, một ví dụ mỗi batch sẽ được truyền cho `function`. Nếu `batch_size <= 0` hoặc `batch_size == None`, toàn bộ tập dữ liệu sẽ được cung cấp như một batch duy nhất cho `function`. keep_in_memory (`bool`, mặc định là `False`) : Giữ bộ dữ liệu trong bộ nhớ thay vì ghi nó vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ kết quả tính toán hiện tại của `function`, hãy sử dụng tệp đó thay vì tính toán lại. cache_file_name (`str`, *tùy chọn*) : Cung cấp tên của đường dẫn cho tệp cache. Nó được sử dụng để lưu trữ kết quả của phép tính thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. fn_kwargs (`dict`, *tùy chọn*) : Các đối số từ khóa để truyền cho `function`. num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình cần sử dụng cho đa tiến trình. - Nếu là `None` hoặc `0`, sẽ không sử dụng đa tiến trình và thao tác được thực thi trong tiến trình chính. - Nếu lớn hơn `1`, một hoặc nhiều tiến trình worker sẽ được sử dụng để xử lý dữ liệu song song. Lưu ý: Hàm được truyền vào `map()` phải có thể picklable để đa tiến trình hoạt động chính xác (tức là nên ưu tiên các hàm được định nghĩa ở cấp độ trên cùng của một module, thay vì bên trong một hàm hoặc lớp khác). suffix_template (`str`) : Nếu `cache_file_name` được chỉ định, hậu tố này sẽ được thêm vào cuối tên gốc của mỗi tệp. Ví dụ, nếu `cache_file_name` là `"processed.arrow"`, thì với `rank = 1` và `num_proc = 4`, tệp kết quả sẽ là `"processed_00001_of_00004.arrow"` với hậu tố mặc định (mặc định là `_{rank:05d}_of_{num_proc:05d}`). new_fingerprint (`str`, *tùy chọn*) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. desc (`str`, *tùy chọn*, mặc định là `None`) : Mô tả có ý nghĩa để hiển thị cùng với thanh tiến trình trong khi lọc các ví dụ. Áp dụng một hàm lọc lên tất cả các phần tử trong bảng theo từng lô và cập nhật bảng để tập dữ liệu chỉ bao gồm các ví dụ theo hàm lọc. Nếu hàm là bất đồng bộ, thì `filter` sẽ chạy hàm của bạn song song, với tối đa một nghìn cuộc gọi đồng thời (có thể cấu hình). Khuyến nghị sử dụng `asyncio.Semaphore` trong hàm của bạn nếu bạn muốn đặt số lượng tối đa các thao tác có thể chạy cùng lúc. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.filter(lambda x: x["label"] == 1) >>> ds Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` #### chọn[[datasets.Dataset.select]] ```python select(indices: Iterable, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4364) **Tham số:** indices (`range`, `list`, `iterable`, `ndarray` hoặc `Series`) : Phạm vi, danh sách hoặc mảng 1 chiều chứa các chỉ số nguyên để lập chỉ mục. Nếu các chỉ số tương ứng với một phạm vi liên tục, bảng Arrow sẽ chỉ được cắt (slice). Tuy nhiên, việc truyền vào một danh sách các chỉ số không liên tục sẽ tạo ra ánh xạ chỉ số, điều này kém hiệu quả hơn nhiều nhưng vẫn nhanh hơn so với việc tạo lại một bảng Arrow gồm các dòng được yêu cầu. keep_in_memory (`bool`, mặc định là `False`) : Giữ ánh xạ chỉ số trong bộ nhớ thay vì ghi vào tệp cache. indices_cache_file_name (`str`, *tùy chọn*, mặc định là `None`) : Cung cấp tên của đường dẫn cho tệp cache. Nó được dùng để lưu trữ các chỉ số ánh xạ thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. new_fingerprint (`str`, *tùy chọn*, mặc định là `None`) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu là `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. Tạo một tập dữ liệu mới với các dòng được chọn theo danh sách/mảng các chỉ số. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.select(range(4)) >>> ds Dataset({ features: ['text', 'label'], num_rows: 4 }) ``` #### sort[[datasets.Dataset.sort]] ```python sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4705) **Tham số:** column_names (`Union[str, Sequence[str]]`) : Tên cột để sắp xếp. reverse (`Union[bool, Sequence[bool]]`, mặc định là `False`) : Nếu `True`, sắp xếp theo thứ tự giảm dần thay vì tăng dần. Nếu chỉ cung cấp một giá trị bool, giá trị đó sẽ được áp dụng cho việc sắp xếp của tất cả tên cột. Ngược lại, phải cung cấp một danh sách các giá trị bool có cùng độ dài và thứ tự với column_names. null_placement (`str`, mặc định là `at_end`) : Đặt các giá trị `None` ở đầu nếu là `at_start` hoặc `first`, hoặc ở cuối nếu là `at_end` hoặc `last` keep_in_memory (`bool`, mặc định là `False`) : Giữ các chỉ số đã sắp xếp trong bộ nhớ thay vì ghi chúng vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ các chỉ số đã sắp xếp, hãy sử dụng tệp đó thay vì tính toán lại. indices_cache_file_name (`str`, *tùy chọn*, mặc định là `None`) : Cung cấp tên của đường dẫn cho tệp cache. Nó được dùng để lưu trữ các chỉ số đã sắp xếp thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị cao hơn tạo ra các tệp cache nhỏ hơn, giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn. new_fingerprint (`str`, *tùy chọn*, mặc định là `None`) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi Tạo một tập dữ liệu mới được sắp xếp theo một hoặc nhiều cột. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes', split='validation') >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ``` #### shuffle[[datasets.Dataset.shuffle]] ```python shuffle(seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4833) **Tham số:** seed (`int`, *optional*) : Một seed để khởi tạo BitGenerator mặc định nếu `generator=None`. Nếu là `None`, entropy mới, không thể đoán trước sẽ được lấy từ hệ điều hành. Nếu một `int` hoặc `array_like[ints]` được truyền vào, nó sẽ được truyền đến SeedSequence để suy ra trạng thái BitGenerator ban đầu. generator (`numpy.random.Generator`, *tùy chọn*) : Numpy random Generator được sử dụng để tính hoán vị các dòng của tập dữ liệu. Nếu `generator=None` (mặc định), sẽ sử dụng `np.random.default_rng` (BitGenerator mặc định (PCG64) của NumPy). keep_in_memory (`bool`, mặc định `False`) : Giữ các chỉ số đã xáo trộn trong bộ nhớ thay vì ghi chúng vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ các chỉ số đã xáo trộn, hãy sử dụng tệp đó thay vì tính toán lại. indices_cache_file_name (`str`, *tùy chọn*) : Cung cấp tên của đường dẫn cho tệp cache. Nó được dùng để lưu trữ các chỉ số đã xáo trộn thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. new_fingerprint (`str`, *tùy chọn*, mặc định là `None`) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu là `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi. Tạo một Dataset mới trong đó các hàng được xáo trộn. Hiện tại, shuffling sử dụng các bộ tạo ngẫu nhiên của numpy. Bạn có thể cung cấp một NumPy BitGenerator để sử dụng, hoặc một seed để khởi tạo bộ tạo ngẫu nhiên mặc định của NumPy (PCG64). Shuffling lấy danh sách các chỉ số `[0:len(my_dataset)]` và xáo trộn nó để tạo ra một ánh xạ chỉ số. Tuy nhiên, ngay khi [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) của bạn có một ánh xạ chỉ số, tốc độ có thể chậm đi 10 lần. Điều này là do có một bước bổ sung để lấy chỉ số hàng cần đọc bằng cách sử dụng ánh xạ chỉ số, và quan trọng nhất là bạn không còn đọc các khối dữ liệu liên tục nữa. Để khôi phục tốc độ, bạn cần ghi đè lại toàn bộ dataset trên đĩa của mình bằng cách sử dụng [Dataset.flatten_indices()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.flatten_indices), hàm này sẽ loại bỏ ánh xạ chỉ số. Tuy nhiên, quá trình này có thể mất rất nhiều thời gian tùy thuộc vào kích thước bộ dữ liệu của bạn: ```python my_dataset[0] # fast my_dataset = my_dataset.shuffle(seed=42) my_dataset[0] # up to 10x slower my_dataset = my_dataset.flatten_indices() # rewrite the shuffled dataset on disk as contiguous chunks of data my_dataset[0] # fast again ``` Trong trường hợp này, chúng tôi khuyến nghị chuyển sang [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) và tận dụng phương pháp xáo trộn gần đúng nhanh của nó [IterableDataset.shuffle()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.shuffle). Nó chỉ xáo trộn thứ tự các shard và thêm một bộ đệm xáo trộn vào tập dữ liệu của bạn, giúp duy trì tốc độ tối ưu cho tập dữ liệu: ```python my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=128) for example in enumerate(my_iterable_dataset): # fast pass shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100) for example in enumerate(shuffled_iterable_dataset): # as fast as before pass ``` Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds['label'][:10] [1, 0, 1, 1, 0, 0, 0, 0, 0, 0] ``` #### bỏ qua[[datasets.Dataset.skip]] ```python skip(n: int) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4617) **Tham số:** n (`int`) : Số phần tử cần bỏ qua. Tạo một [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) mới bỏ qua `n` phần tử đầu tiên. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}] ``` #### take[[datasets.Dataset.take]] ```python take(n: int) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4679) **Tham số:** n (`int`) : Số lượng phần tử cần lấy. Tạo một [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) mới chỉ chứa `n` phần tử đầu tiên. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}] ``` #### train_test_split[[datasets.Dataset.train_test_split]] ```python train_test_split(test_size: typing.Union[float, int, NoneType] = None, train_size: typing.Union[float, int, NoneType] = None, shuffle: bool = True, stratify_by_column: typing.Optional[str] = None, seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, train_indices_cache_file_name: typing.Optional[str] = None, test_indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, train_new_fingerprint: typing.Optional[str] = None, test_new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4970) **Tham số:** test_size (`Union[float, int, None]`, *tùy chọn*) : Kích thước của phần kiểm tra. Nếu là `float`, giá trị phải nằm trong khoảng từ `0.0` đến `1.0` và đại diện cho tỷ lệ tập dữ liệu được đưa vào phần kiểm tra. Nếu là `int`, đại diện cho số lượng mẫu kiểm tra tuyệt đối. Nếu là `None`, giá trị sẽ được đặt bằng phần bù của kích thước tập huấn luyện. Nếu `train_size` cũng là `None`, giá trị sẽ được đặt thành `0.25`. train_size (`Union[float, int, None]`, *tùy chọn*) : Kích thước của phần chia train. Nếu là `float`, giá trị phải nằm trong khoảng từ `0.0` đến `1.0` và đại diện cho tỷ lệ tập dữ liệu được đưa vào phần chia train. Nếu là `int`, đại diện cho số lượng mẫu train tuyệt đối. Nếu là `None`, giá trị sẽ được tự động đặt thành phần bù của kích thước test. shuffle (`bool`, *tùy chọn*, mặc định là `True`) : Có trộn dữ liệu trước khi tách hay không. stratify_by_column (`str`, *tùy chọn*, mặc định là `None`) : Tên cột của nhãn được sử dụng để thực hiện chia dữ liệu theo phân tầng. seed (`int`, *optional*) : Một seed để khởi tạo BitGenerator mặc định nếu `generator=None`. Nếu là `None`, entropy mới, không thể đoán trước sẽ được lấy từ hệ điều hành. Nếu một `int` hoặc `array_like[ints]` được truyền vào, nó sẽ được truyền đến SeedSequence để suy ra trạng thái BitGenerator ban đầu. generator (`numpy.random.Generator`, *tùy chọn*) : Numpy random Generator được sử dụng để tính hoán vị các dòng của tập dữ liệu. Nếu `generator=None` (mặc định), sẽ sử dụng `np.random.default_rng` (BitGenerator mặc định (PCG64) của NumPy). keep_in_memory (`bool`, mặc định là `False`) : Giữ các chỉ số phân chia trong bộ nhớ thay vì ghi chúng vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ các chỉ số splits, hãy sử dụng nó thay vì tính toán lại. train_cache_file_name (`str`, *tùy chọn*) : Cung cấp tên của đường dẫn cho tệp cache. Nó được dùng để lưu trữ các chỉ số của phần chia train thay vì tên tệp cache được tạo tự động. test_cache_file_name (`str`, *tùy chọn*) : Cung cấp tên của đường dẫn cho tệp cache. Nó được dùng để lưu trữ các chỉ số của tập kiểm tra thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. train_new_fingerprint (`str`, *tùy chọn*, mặc định là `None`) : Dấu vân tay mới của tập huấn luyện sau khi biến đổi. Nếu là `None`, dấu vân tay mới sẽ được tính toán bằng cách băm dấu vân tay trước đó và các đối số của phép biến đổi test_new_fingerprint (`str`, *tùy chọn*, mặc định là `None`) : Dấu vân tay mới của tập dữ liệu kiểm tra sau khi biến đổi. Nếu là `None`, dấu vân tay mới sẽ được tính toán bằng cách băm dấu vân tay trước đó và các đối số của phép biến đổi Trả về một từ điển ([datasets.DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict)) chứa hai tập con train và test ngẫu nhiên (các phần chia `Dataset` `train` và `test`). Các phần chia được tạo từ tập dữ liệu dựa trên `test_size`, `train_size` và `shuffle`. Phương pháp này tương tự như `train_test_split` của scikit-learn. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.train_test_split(test_size=0.2, shuffle=True) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 852 }) test: Dataset({ features: ['text', 'label'], num_rows: 214 }) }) # set a seed >>> ds = ds.train_test_split(test_size=0.2, seed=42) # stratified split >>> ds = load_dataset("stanfordnlp/imdb",split="train") Dataset({ features: ['text', 'label'], num_rows: 25000 }) >>> ds = ds.train_test_split(test_size=0.2, stratify_by_column="label") DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 20000 }) test: Dataset({ features: ['text', 'label'], num_rows: 5000 }) }) ``` #### shard[[datasets.Dataset.shard]] ```python shard(num_shards: int, index: int, contiguous: bool = True, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5253) **Tham số:** num_shards (`int`) : Số lượng shard để chia bộ dữ liệu. index (`int`) : Shard cần chọn và trả về. contiguous : (`bool`, mặc định là `True`): Có nên chọn các khối chỉ số liên tục cho các shard hay không. keep_in_memory (`bool`, mặc định là `False`) : Giữ bộ dữ liệu trong bộ nhớ thay vì ghi nó vào tệp cache. indices_cache_file_name (`str`, *tùy chọn*) : Cung cấp tên của đường dẫn cho tệp cache. Nó được dùng để lưu trữ các chỉ mục của từng shard thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Điều này chỉ liên quan đến ánh xạ chỉ mục. Số lượng chỉ mục cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa việc sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn khiến quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. Trả về shard thứ `index` từ tập dữ liệu được chia thành `num_shards` phần. Thao tác này chia nhỏ dữ liệu một cách tất định. `dataset.shard(n, i)` chia bộ dữ liệu thành các khối liên tục, do đó có thể dễ dàng nối lại sau khi xử lý. Nếu `len(dataset) % n == l`, thì `l` bộ dữ liệu đầu tiên mỗi bộ có độ dài `(len(dataset) // n) + 1`, và các bộ dữ liệu còn lại có độ dài `(len(dataset) // n)`. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` trả về một bộ dữ liệu có cùng thứ tự như bản gốc. Lưu ý: n phải nhỏ hơn hoặc bằng số phần tử trong tập dữ liệu `len(dataset)`. Mặt khác, `dataset.shard(n, i, contiguous=False)` chứa tất cả các phần tử của tập dữ liệu có chỉ số mod `n = i`. Hãy đảm bảo thực hiện chia shard trước khi sử dụng bất kỳ toán tử ngẫu nhiên hóa nào (chẳng hạn như `shuffle`). Tốt nhất là toán tử shard nên được sử dụng sớm trong pipeline của dataset. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds Dataset({ features: ['text', 'label'], num_rows: 1066 }) >>> ds = ds.shard(num_shards=2, index=0) >>> ds Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` #### repeat[[datasets.Dataset.repeat]] ```python repeat(num_times: int) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4647) **Tham số:** num_times (`int`) : Số lần lặp lại bộ dữ liệu. Tạo một [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) mới lặp lại tập dữ liệu cơ bản `num_times` lần. Tương tự như itertools.repeat, việc lặp lại một lần chỉ trả về toàn bộ tập dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds = ds.take(2).repeat(2) >>> list(ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] ``` #### to_tf_dataset[[datasets.Dataset.to_tf_dataset]] ```python to_tf_dataset(batch_size: typing.Optional[int] = None, columns: typing.Union[str, list[str], NoneType] = None, shuffle: bool = False, collate_fn: typing.Optional[typing.Callable] = None, drop_remainder: bool = False, collate_fn_args: typing.Optional[dict[str, typing.Any]] = None, label_cols: typing.Union[str, list[str], NoneType] = None, prefetch: bool = True, num_workers: int = 0, num_test_batches: int = 20) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L336) **Tham số:** batch_size (`int`, *tuỳ chọn*) : Kích thước của các lô (batch) để tải từ tập dữ liệu. Mặc định là `None`, điều này có nghĩa là tập dữ liệu sẽ không được chia thành các lô, nhưng tập dữ liệu trả về có thể được chia lô sau đó bằng `tf_dataset.batch(batch_size)`. columns (`List[str]` hoặc `str`, *tùy chọn*) : Cột dữ liệu cần nạp vào `tf.data.Dataset`. Có thể sử dụng tên các cột được tạo bởi `collate_fn` và không tồn tại trong dataset gốc. shuffle(`bool`, mặc định là `False`) : Xáo trộn thứ tự của tập dữ liệu khi tải. Khuyến nghị dùng `True` cho huấn luyện, `False` cho kiểm tra/đánh giá. drop_remainder(`bool`, mặc định là `False`) : Bỏ qua lô dữ liệu cuối cùng không đầy đủ khi tải. Đảm bảo rằng tất cả các lô dữ liệu do tập dữ liệu tạo ra sẽ có cùng độ dài trên chiều batch. collate_fn(`Callable`, *tuỳ chọn*) : Một hàm hoặc đối tượng có thể gọi (chẳng hạn như `DataCollator`) sẽ gom các danh sách mẫu thành một batch. collate_fn_args (`Dict`, *tùy chọn*) : Một `dict` tùy chọn chứa các đối số theo tên để truyền cho `collate_fn`. label_cols (`List[str]` hoặc `str`, mặc định là `None`) : Cột dữ liệu (dataset column) để tải dưới dạng nhãn (labels). Lưu ý rằng nhiều mô hình tự tính toán loss bên trong thay vì để Keras thực hiện, trong trường hợp đó việc truyền nhãn ở đây là tùy chọn, miễn là chúng có mặt trong các `columns` đầu vào. prefetch (`bool`, mặc định là `True`) : Xác định có chạy dataloader trong một thread riêng và duy trì một bộ đệm nhỏ các batch cho quá trình huấn luyện hay không. Cải thiện hiệu suất bằng cách cho phép tải dữ liệu ở nền trong khi mô hình đang được huấn luyện. num_workers (`int`, mặc định là `0`) : Số lượng worker để sử dụng khi tải dataset. num_test_batches (`int`, mặc định là `20`) : Số lượng batch được sử dụng để suy luận chữ ký đầu ra của tập dữ liệu. Con số này càng cao thì chữ ký càng chính xác, nhưng thời gian tạo tập dữ liệu sẽ càng lâu. **Trả về:** `tf.data.Dataset` Tạo một `tf.data.Dataset` từ Dataset cơ sở. `tf.data.Dataset` này sẽ tải và collate các batch từ Dataset, và phù hợp để truyền vào các phương thức như `model.fit()` hoặc `model.predict()`. Dataset sẽ trả về các `dicts` cho cả inputs và labels, trừ khi `dict` chỉ chứa một key duy nhất, trong trường hợp đó một `tf.Tensor` thô sẽ được trả về thay thế. Ví dụ: ```py >>> ds_train = ds["train"].to_tf_dataset( ... columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'], ... shuffle=True, ... batch_size=16, ... collate_fn=data_collator, ... ) ``` #### push_to_hub[[datasets.Dataset.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6080) **Tham số:** repo_id (`str`) : ID của kho cần đẩy lên, theo định dạng: `/` hoặc `/`. Cũng chấp nhận ``, khi đó sẽ mặc định dùng namespace của người dùng đang đăng nhập. Cũng có thể là một vị trí bên trong bucket, ví dụ `buckets///...` config_name (`str`, mặc định là "default") : Tên cấu hình (hoặc tập con) của một bộ dữ liệu. Mặc định là "default". set_default (`bool`, *tùy chọn*) : Có nên đặt cấu hình này làm cấu hình mặc định hay không. Nếu không, cấu hình mặc định sẽ là cấu hình có tên "default". split (`str`, *tùy chọn*) : Tên của phần chia (split) sẽ được gán cho tập dữ liệu đó. Mặc định là `self.split`. data_dir (`str`, *tùy chọn*) : Tên thư mục sẽ chứa các tệp dữ liệu đã tải lên. Mặc định là `config_name` nếu khác "default", nếu không thì là "data". commit_message (`str`, *tùy chọn*) : Thông điệp để commit khi đẩy. Mặc định là `"Upload dataset"`. commit_description (`str`, *tùy chọn*) : Mô tả của commit sẽ được tạo. Ngoài ra, mô tả của PR nếu một PR được tạo (`create_pr` là True). private (`bool`, *tuỳ chọn*) : Có nên đặt kho thành riêng tư hay không. Nếu là `None` (mặc định), kho sẽ là công khai trừ khi mặc định của tổ chức là riêng tư. Giá trị này bị bỏ qua nếu kho đã tồn tại. token (`str`, *tùy chọn*) : Một token xác thực tùy chọn cho Hugging Face Hub. Nếu không truyền token, hệ thống sẽ mặc định sử dụng token được lưu cục bộ khi đăng nhập bằng `hf auth login`. Sẽ gây ra lỗi nếu không truyền token và người dùng chưa đăng nhập. revision (`str`, *tùy chọn*) : Nhánh để đẩy các tệp đã tải lên. Mặc định là nhánh `"main"`. create_pr (`bool`, *tùy chọn*, mặc định là `False`) : Có tạo PR với các tệp đã tải lên hay commit trực tiếp hay không. max_shard_size (`int` hoặc `str`, *không bắt buộc*, mặc định là `"500MB"`) : Kích thước tối đa của các shard dữ liệu sẽ được tải lên hub. Nếu được biểu diễn dưới dạng chuỗi, cần là các chữ số theo sau bởi một đơn vị (ví dụ `"5MB"`). num_shards (`int`, *tùy chọn*) : Số lượng shard cần ghi. Mặc định, số lượng shard phụ thuộc vào `max_shard_size`. embed_external_files (`bool`, mặc định là `True`) : Xác định có nhúng byte của tệp vào các shard hay không. Cụ thể, trước khi đẩy lên, thao tác này sẽ thực hiện các bước sau cho các trường có kiểu: - [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) và [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image): xóa thông tin đường dẫn cục bộ và nhúng nội dung tệp vào các tệp Parquet. num_proc (`int`, *optional*, mặc định là `None`) : Số lượng tiến trình khi chuẩn bị và tải lên bộ dữ liệu. Điều này hữu ích nếu bộ dữ liệu gồm nhiều mẫu hoặc tệp phương tiện cần nhúng. I sử dụng ngữ cảnh "spawn" để hoạt động với hf_xet, client rust cho việc tải lên HF nhanh chóng. Đa tiến trình bị vô hiệu hóa theo mặc định. **Trả về:** huggingface_hub.CommitInfo Đẩy dataset lên hub dưới dạng dataset Parquet. Dataset được đẩy bằng các yêu cầu HTTP và không cần cài đặt git hoặc git-lfs. Các tệp Parquet kết quả mặc định là tự chứa. Nếu tập dữ liệu của bạn chứa dữ liệu [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) hoặc [Video](/docs/datasets/main/vi/package_reference/main_classes#datasets.Video), các tệp Parquet sẽ lưu trữ các byte của tệp hình ảnh hoặc âm thanh của bạn. Bạn có thể tắt điều này bằng cách đặt `embed_external_files` thành `False`. Ví dụ: ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Nếu tập dữ liệu của bạn có nhiều phần chia (ví dụ: train/validation/test): ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Nếu bạn muốn thêm một cấu hình (hoặc tập con) mới vào một tập dữ liệu (ví dụ: nếu tập dữ liệu có nhiều tác bản/phân bản/ngôn ngữ): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### save_to_disk[[datasets.Dataset.save_to_disk]] ```python save_to_disk(dataset_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1781) **Tham số:** dataset_path (`path-like`) : Path (ví dụ `dataset/train`) hoặc URI từ xa (ví dụ `s3://my-bucket/dataset/train`) của thư mục dataset nơi dataset sẽ được lưu. max_shard_size (`int` hoặc `str`, *không bắt buộc*, mặc định là `"500MB"`) : Kích thước tối đa của các shard dữ liệu sẽ được lưu vào hệ thống tệp. Nếu được biểu diễn dưới dạng chuỗi, cần phải là các chữ số theo sau bởi một đơn vị (ví dụ `"50MB"`). num_shards (`int`, *optional*) : Số lượng shard cần ghi. Mặc định, số lượng shard phụ thuộc vào `max_shard_size` và `num_proc`. num_proc (`int`, *optional*) : Số lượng tiến trình khi tải xuống và tạo bộ dữ liệu cục bộ. Đa tiến trình bị vô hiệu hóa theo mặc định. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. Lưu một dataset vào thư mục dataset, hoặc vào hệ thống tệp bằng bất kỳ cài đặt nào của `fsspec.spec.AbstractFileSystem`. Đối với dữ liệu [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) và [Video](/docs/datasets/main/vi/package_reference/main_classes#datasets.Video): Tất cả dữ liệu Image(), Audio() và Video() được lưu trữ trong các tệp arrow. Nếu bạn muốn lưu trữ đường dẫn hoặc url, vui lòng sử dụng kiểu Value("string"). Ví dụ: ```py >>> ds.save_to_disk("path/to/dataset/directory") >>> ds.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> ds.save_to_disk("path/to/dataset/directory", num_shards=1024) ``` #### load_from_disk[[datasets.Dataset.load_from_disk]] ```python load_from_disk(dataset_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1977) **Tham số:** dataset_path (`path-like`) : Path (ví dụ `"dataset/train"`) hoặc URI từ xa (ví dụ `"s3//my-bucket/dataset/train"`) của thư mục dataset mà dataset sẽ được tải từ đó. keep_in_memory (`bool`, mặc định là `None`) : Có sao chép bộ dữ liệu trong bộ nhớ hay không. Nếu là `None`, bộ dữ liệu sẽ không được sao chép trong bộ nhớ trừ khi được bật rõ ràng bằng cách đặt `datasets.config.IN_MEMORY_MAX_SIZE` thành giá trị khác không. Xem thêm chi tiết trong phần [cải thiện hiệu suất](../cache#improve-performance). storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) hoặc [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) - Nếu `dataset_path` là đường dẫn của một thư mục dataset, thì đó là dataset được yêu cầu. - Nếu `dataset_path` là đường dẫn của một thư mục dict tập dữ liệu, một `datasets.DatasetDict` với mỗi split. Tải một tập dữ liệu đã được lưu trước đó bằng `save_to_disk` từ một thư mục tập dữ liệu, hoặc từ một hệ thống tệp bằng bất kỳ cài đặt nào của `fsspec.spec.AbstractFileSystem`. Ví dụ: ```py >>> ds = load_from_disk("path/to/dataset/directory") ``` #### flatten_indices[[datasets.Dataset.flatten_indices]] ```python flatten_indices(keep_in_memory: bool = False, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, num_proc: typing.Optional[int] = None, new_fingerprint: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4285) **Tham số:** keep_in_memory (`bool`, mặc định là `False`) : Giữ bộ dữ liệu trong bộ nhớ thay vì ghi nó vào tệp cache. cache_file_name (`str`, *tùy chọn*, mặc định `None`) : Cung cấp tên của đường dẫn cho tệp cache. Nó được sử dụng để lưu trữ kết quả của phép tính thay vì tên tệp cache được tạo tự động. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. features (`Optional[datasets.Features]`, mặc định là `None`) : Sử dụng một [Features](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features) cụ thể để lưu trữ tệp cache thay vì tệp được tạo tự động. disable_nullable (`bool`, mặc định là `False`) : Cho phép các giá trị null trong bảng. num_proc (`int`, tùy chọn, mặc định `None`) : Số lượng tiến trình tối đa khi tạo bộ nhớ đệm. Các shard đã được lưu trong bộ nhớ đệm sẽ được nạp tuần tự new_fingerprint (`str`, *tùy chọn*, mặc định là `None`) : Dấu vân tay mới của bộ dữ liệu sau khi biến đổi. Nếu `None`, dấu vân tay mới sẽ được tính toán bằng cách sử dụng băm của dấu vân tay trước đó và các đối số biến đổi Tạo và lưu vào bộ nhớ đệm một Dataset mới bằng cách làm phẳng ánh xạ chỉ số. #### to_csv[[datasets.Dataset.to_csv]] ```python to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5330) **Tham số:** path_or_buf (`PathLike` hoặc `FileOrBuffer`) : Một đường dẫn đến tệp (ví dụ: `file.csv`), một URI từ xa (ví dụ: `hf://datasets/username/my_dataset_name/data.csv`), hoặc một BinaryIO, nơi bộ dữ liệu sẽ được lưu trữ theo định dạng được chỉ định. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi lại một lúc. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *optional*) : Số lượng tiến trình cho multiprocessing. Mặc định không sử dụng multiprocessing. `batch_size` trong trường hợp này mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE` nhưng bạn có thể tăng lên 5 lần hoặc 10 lần giá trị mặc định nếu có đủ sức mạnh tính toán. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. - ****to_csv_kwargs** (các tham số bổ sung): Các tham số để truyền cho [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) của pandas. Bây giờ, `index` mặc định là `False` nếu không được chỉ định. Nếu bạn muốn ghi index, hãy truyền `index=True` và cũng đặt tên cho cột index bằng cách truyền `index_label`. **Trả về:** `int` Số lượng ký tự hoặc byte đã được ghi. Xuất bộ dữ liệu ra csv Ví dụ: ```py >>> ds.to_csv("path/to/dataset/directory") ``` #### to_pandas[[datasets.Dataset.to_pandas]] ```python to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5529) **Tham số:** batch_size (`int`, *tuỳ chọn*) : Kích thước (số dòng) của các lô nếu `batched` là `True`. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Đặt thành `True` để trả về một generator tạo ra dataset theo các lô gồm `batch_size` hàng. Mặc định là `False` (trả về toàn bộ dataset một lần). **Trả về:** `pandas.DataFrame` hoặc `Iterator[pandas.DataFrame]` Trả về tập dữ liệu dưới dạng `pandas.DataFrame`. Cũng có thể trả về một generator cho các tập dữ liệu lớn. Ví dụ: ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.Dataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5389) **Tham số:** batch_size (`int`, *tuỳ chọn*) : Kích thước (số dòng) của các lô nếu `batched` là `True`. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Đặt thành `True` để trả về một generator tạo ra dataset theo các lô gồm `batch_size` hàng. Mặc định là `False` (trả về toàn bộ dataset một lần). **Trả về:** `dict` hoặc `Iterator[dict]` Trả về tập dữ liệu dưới dạng dict Python. Cũng có thể trả về một generator cho các tập dữ liệu lớn. Ví dụ: ```py >>> ds.to_dict() ``` #### to_json[[datasets.Dataset.to_json]] ```python to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5454) **Tham số:** path_or_buf (`PathLike` hoặc `FileOrBuffer`) : Một đường dẫn đến tệp (ví dụ: `file.json`), một URI từ xa (ví dụ: `hf://datasets/username/my_dataset_name/data.json`), hoặc một BinaryIO, nơi bộ dữ liệu sẽ được lưu trữ theo định dạng được chỉ định. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi lại một lúc. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *optional*) : Số lượng tiến trình cho multiprocessing. Mặc định, nó không sử dụng multiprocessing. `batch_size` trong trường hợp này mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE` nhưng bạn có thể tăng lên 5 lần hoặc 10 lần giá trị mặc định nếu bạn có đủ sức mạnh tính toán. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. - ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`. **Trả về:** `int` Số lượng ký tự hoặc byte đã được ghi. Xuất dataset ra JSON Lines hoặc JSON. Định dạng đầu ra mặc định là [JSON Lines](https://jsonlines.org/). Để xuất sang [JSON](https://www.json.org), hãy truyền tham số `lines=False` và `orient` mong muốn. Ví dụ: ```py >>> ds.to_json("path/to/dataset/directory/filename.jsonl") ``` #### to_parquet[[datasets.Dataset.to_parquet]] ```python to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5631) **Tham số:** path_or_buf (`PathLike` hoặc `FileOrBuffer`) : Một đường dẫn đến tệp (ví dụ: `file.parquet`), một URI từ xa (ví dụ: `hf://datasets/username/my_dataset_name/data.parquet`), hoặc một BinaryIO, nơi bộ dữ liệu sẽ được lưu trữ theo định dạng được chỉ định. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi một lần. Mặc định, nó hướng tới các nhóm hàng có kích thước byte chưa nén tối đa là "100MB", được định nghĩa bởi `datasets.config.MAX_ROW_GROUP_SIZE`. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. - ****parquet_writer_kwargs** (các tham số bổ sung): Các tham số để truyền cho `pyarrow.parquet.ParquetWriter` của PyArrow. **Trả về:** `int` Số lượng ký tự hoặc byte đã được ghi. Xuất bộ dữ liệu ra parquet Ví dụ: ```py >>> ds.to_parquet("path/to/dataset/directory") ``` #### to_sql[[datasets.Dataset.to_sql]] ```python to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, **sql_writer_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5671) **Tham số:** name (`str`) : Tên bảng SQL. con (`str` hoặc `sqlite3.Connection` hoặc `sqlalchemy.engine.Connection` hoặc `sqlalchemy.engine.Connection`) : Một [chuỗi URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) hoặc một đối tượng kết nối SQLite3/SQLAlchemy được sử dụng để ghi vào cơ sở dữ liệu. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi lại một lúc. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *optional*) : Số lượng tiến trình cho multiprocessing. Mặc định, nó không sử dụng multiprocessing. `batch_size` trong trường hợp này mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE` nhưng bạn có thể tăng lên 5 lần hoặc 10 lần giá trị mặc định nếu bạn có đủ sức mạnh tính toán. - ****sql_writer_kwargs** (các tham số bổ sung): Các tham số để truyền cho [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) của pandas. Bây giờ, `index` mặc định là `False` nếu không được chỉ định. Nếu bạn muốn ghi index, hãy truyền `index=True` và cũng đặt tên cho cột index bằng cách truyền `index_label`. **Trả về:** `int` Số lượng bản ghi đã được ghi. Xuất bộ dữ liệu ra cơ sở dữ liệu SQL. Ví dụ: ```py >>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con) ``` #### to_iterable_dataset[[datasets.Dataset.to_iterable_dataset]] ```python to_iterable_dataset(num_shards: typing.Optional[int] = 1) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5769) **Tham số:** num_shards (`int`, mặc định là `1`) : Số lượng shard cần định nghĩa khi khởi tạo bộ dữ liệu dạng iterable. Điều này đặc biệt hữu ích cho các bộ dữ liệu lớn để có thể xáo trộn (shuffle) đúng cách, đồng thời cho phép tải song song nhanh chóng bằng PyTorch DataLoader hoặc trong các cấu hình phân tán, chẳng hạn. Các shard được định nghĩa bằng [datasets.Dataset.shard()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.shard): nó chỉ đơn giản là cắt dữ liệu mà không ghi bất cứ thứ gì xuống đĩa. **Trả về:** [datasets.IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Lấy một [datasets.IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) từ một [datasets.Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) dạng map. Điều này tương đương với việc tải một dataset ở chế độ streaming bằng [datasets.load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset), nhưng nhanh hơn nhiều vì dữ liệu được stream từ các tệp cục bộ. Ngược lại với các dataset kiểu map, các dataset kiểu iterable là lười (lazy) và chỉ có thể được lặp qua (ví dụ: bằng vòng lặp for). Vì chúng được đọc tuần tự trong các vòng lặp huấn luyện, các dataset kiểu iterable nhanh hơn nhiều so với các dataset kiểu map. Tất cả các phép biến đổi được áp dụng cho các dataset kiểu iterable, chẳng hạn như lọc hoặc xử lý, đều được thực hiện theo thời gian thực khi bạn bắt đầu lặp qua dataset. Tuy nhiên, bạn vẫn có thể xáo trộn một tập dữ liệu dạng lặp được bằng cách sử dụng [datasets.IterableDataset.shuffle()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.shuffle). Đây là một phương pháp xáo trộn gần đúng nhanh chóng, hoạt động tốt nhất khi bạn có nhiều shard và khi bạn chỉ định kích thước bộ đệm đủ lớn. Để đạt hiệu suất tốc độ tốt nhất, hãy đảm bảo tập dữ liệu của bạn không có ánh xạ chỉ số. Nếu có, dữ liệu sẽ không được đọc liên tục, điều này đôi khi có thể gây chậm. Bạn có thể sử dụng `ds = ds.flatten_indices()` để ghi tập dữ liệu của bạn thành các khối dữ liệu liên tục và có tốc độ tối ưu trước khi chuyển sang tập dữ liệu dạng lặp. Ví dụ: Cách sử dụng cơ bản: ```python >>> ids = ds.to_iterable_dataset() >>> for example in ids: ... pass ``` Với lọc và xử lý theo kiểu lười (lazy): ```python >>> ids = ds.to_iterable_dataset() >>> ids = ids.filter(filter_fn).map(process_fn) # will filter and process on-the-fly when you start iterating over the iterable dataset >>> for example in ids: ... pass ``` Với sharding để cho phép xáo trộn hiệu quả: ```python >>> ids = ds.to_iterable_dataset(num_shards=64) # the dataset is split into 64 shards to be iterated over >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer for fast approximate shuffling when you start iterating >>> for example in ids: ... pass ``` Với một PyTorch DataLoader: ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.filter(filter_fn).map(process_fn) >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards to each worker to load, filter and process when you start iterating >>> for example in ids: ... pass ``` Với PyTorch DataLoader và xáo trộn: ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` Trong một cấu hình phân tán như PyTorch DDP với PyTorch DataLoader và xáo trộn ```python >>> from datasets.distributed import split_dataset_by_node >>> ids = ds.to_iterable_dataset(num_shards=512) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> ids = split_dataset_by_node(ds, world_size=8, rank=0) # will keep only 512 / 8 = 64 shards from the shuffled lists of shards when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from this node's list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` Với việc xáo trộn và nhiều epoch: ```python >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> for epoch in range(n_epochs): ... ids.set_epoch(epoch) # will use effective_seed = seed + epoch to shuffle the shards and for the shuffle buffer when you start iterating ... for example in ids: ... pass ``` Bạn cũng có thể sử dụng `IterableDataset.set_epoch()` khi dùng PyTorch DataLoader hoặc trong các cấu hình phân tán. #### add_faiss_index[[datasets.Dataset.add_faiss_index]] ```python add_faiss_index(column: str, index_name: typing.Optional[str] = None, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = ) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6327) **Tham số:** column (`str`) : Cột chứa các vector cần thêm vào chỉ mục. index_name (`str`, *tùy chọn*) : `index_name`/định danh của chỉ mục. Đây là `index_name` được dùng để gọi [get_nearest_examples()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.get_nearest_examples) hoặc [search()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.search). Mặc định, nó tương ứng với `column`. device (`Union[int, List[int]]`, *tùy chọn*) : Nếu là số nguyên dương, đây là chỉ số của GPU cần sử dụng. Nếu là số nguyên âm, sử dụng tất cả các GPU. Nếu truyền vào một danh sách các số nguyên dương, chỉ chạy trên những GPU đó. Mặc định sử dụng CPU. string_factory (`str`, *tùy chọn*) : Giá trị này được truyền vào nhà máy chỉ mục của Faiss để tạo chỉ mục. Lớp chỉ mục mặc định là `IndexFlat`. metric_type (`int`, *tùy chọn*) : Kiểu của metric. VD: `faiss.METRIC_INNER_PRODUCT` hoặc `faiss.METRIC_L2`. custom_index (`faiss.Index`, *optional*) : Chỉ mục Faiss tùy chỉnh mà bạn đã khởi tạo và cấu hình sẵn cho nhu cầu của mình. batch_size (`int`) : Kích thước của batch được sử dụng khi thêm các vector vào `FaissIndex`. Giá trị mặc định là `1000`. train_size (`int`, *optional*) : Nếu index cần một bước huấn luyện, chỉ định số lượng vector sẽ được sử dụng để huấn luyện index. faiss_verbose (`bool`, mặc định là `False`) : Bật tính năng hiển thị chi tiết của chỉ mục Faiss. dtype (`data-type`) : dtype của các mảng numpy được chỉ mục. Mặc định là `np.float32`. Thêm một chỉ mục dense bằng Faiss để truy xuất nhanh. Mặc định, chỉ mục được tạo trên các vector của cột được chỉ định. Bạn có thể chỉ định `device` nếu muốn chạy trên GPU (`device` phải là chỉ số của GPU). Bạn có thể tìm thêm thông tin về Faiss tại đây: - Dành cho [nhà máy chuỗi](https://github.com/facebookresearch/faiss/wiki/The-index-factory) Ví dụ: ```python >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> ds_with_embeddings = ds.map(lambda example: {'embeddings': embed(example['line']})) >>> ds_with_embeddings.add_faiss_index(column='embeddings') >>> # query >>> scores, retrieved_examples = ds_with_embeddings.get_nearest_examples('embeddings', embed('my new query'), k=10) >>> # save index >>> ds_with_embeddings.save_faiss_index('embeddings', 'my_index.faiss') >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> # load index >>> ds.load_faiss_index('embeddings', 'my_index.faiss') >>> # query >>> scores, retrieved_examples = ds.get_nearest_examples('embeddings', embed('my new query'), k=10) ``` #### add_faiss_index_from_external_arrays[[datasets.Dataset.add_faiss_index_from_external_arrays]] ```python add_faiss_index_from_external_arrays(external_arrays: array, index_name: str, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = ) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6407) **Tham số:** external_arrays (`np.array`) : Nếu bạn muốn sử dụng các mảng từ bên ngoài thư viện cho chỉ mục, bạn có thể đặt `external_arrays`. Hệ thống sẽ sử dụng `external_arrays` để tạo chỉ mục Faiss thay vì các mảng trong `column` được chỉ định. index_name (`str`) : `index_name`/định danh của chỉ mục. Đây là `index_name` được dùng để gọi [get_nearest_examples()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.get_nearest_examples) hoặc [search()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.search). device (Tùy chọn `Union[int, List[int]]`, *tùy chọn*) : Nếu là số nguyên dương, đây là chỉ số của GPU cần sử dụng. Nếu là số nguyên âm, sử dụng tất cả các GPU. Nếu truyền vào một danh sách các số nguyên dương, chỉ chạy trên những GPU đó. Mặc định sử dụng CPU. string_factory (`str`, *tùy chọn*) : Giá trị này được truyền vào nhà máy chỉ mục của Faiss để tạo chỉ mục. Lớp chỉ mục mặc định là `IndexFlat`. metric_type (`int`, *tùy chọn*) : Kiểu của metric. VD: `faiss.faiss.METRIC_INNER_PRODUCT` hoặc `faiss.METRIC_L2`. custom_index (`faiss.Index`, *optional*) : Chỉ mục Faiss tùy chỉnh mà bạn đã khởi tạo và cấu hình sẵn cho nhu cầu của mình. batch_size (`int`, *tuỳ chọn*) : Kích thước của batch được sử dụng khi thêm các vector vào FaissIndex. Giá trị mặc định là 1000. train_size (`int`, *optional*) : Nếu index cần một bước huấn luyện, chỉ định số lượng vector sẽ được sử dụng để huấn luyện index. faiss_verbose (`bool`, mặc định là False) : Bật tính năng hiển thị chi tiết của chỉ mục Faiss. dtype (`numpy.dtype`) : dtype của các mảng numpy được chỉ mục. Mặc định là np.float32. Thêm một chỉ mục dense bằng Faiss để truy xuất nhanh. Chỉ mục được tạo bằng các vector của `external_arrays`. Bạn có thể chỉ định `device` nếu muốn chạy trên GPU (`device` phải là chỉ số của GPU). Bạn có thể tìm thêm thông tin về Faiss tại đây: - Dành cho [nhà máy chuỗi](https://github.com/facebookresearch/faiss/wiki/The-index-factory) #### save_faiss_index[[datasets.Dataset.save_faiss_index]] ```python save_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L535) **Tham số:** index_name (`str`) : index_name/định danh của index. Đây là index_name được dùng để gọi `.get_nearest` hoặc `.search`. file (`str`) : Đường dẫn đến chỉ mục faiss đã được serialize trên đĩa hoặc URI từ xa (ví dụ: `"s3://my-bucket/index.faiss"`). storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. Lưu một FaissIndex trên đĩa. #### load_faiss_index[[datasets.Dataset.load_faiss_index]] ```python load_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], device: typing.Union[int, list[int], NoneType] = None, storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L553) **Tham số:** index_name (`str`) : index_name/định danh của index. Đây là index_name được dùng để gọi `.get_nearest` hoặc `.search`. file (`str`) : Đường dẫn đến chỉ mục faiss đã được serialize trên đĩa hoặc URI từ xa (ví dụ: `"s3://my-bucket/index.faiss"`). device (Tùy chọn `Union[int, List[int]]`) : Nếu là số nguyên dương, đây là chỉ số của GPU cần sử dụng. Nếu là số nguyên âm, sử dụng tất cả các GPU. Nếu truyền vào một danh sách các số nguyên dương, chỉ chạy trên những GPU đó. Mặc định sử dụng CPU. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. Tải một FaissIndex từ đĩa. Nếu bạn muốn thực hiện các cấu hình bổ sung, bạn có thể truy cập vào đối tượng chỉ mục faiss bằng cách thực hiện `.get_index(index_name).faiss_index` để phù hợp với nhu cầu của mình. #### add_elasticsearch_index[[datasets.Dataset.add_elasticsearch_index]] ```python add_elasticsearch_index(column: str, index_name: typing.Optional[str] = None, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('elasticsearch.Elasticsearch')] = None, es_index_name: typing.Optional[str] = None, es_index_config: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6466) **Tham số:** column (`str`) : Cột của các tài liệu cần thêm vào chỉ mục. index_name (`str`, *tùy chọn*) : `index_name`/định danh của chỉ mục. Đây là tên chỉ mục được dùng để gọi [get_nearest_examples()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.get_nearest_examples) hoặc [search()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.search). Mặc định, nó tương ứng với `column`. host (`str`, *tùy chọn*, mặc định là `localhost`) : Máy chủ nơi ElasticSearch đang chạy. port (`str`, *tùy chọn*, mặc định là `9200`) : Cổng nơi ElasticSearch đang chạy. es_client (`elasticsearch.Elasticsearch`, *tùy chọn*) : Client elasticsearch được sử dụng để tạo index nếu host và port là `None`. es_index_name (`str`, *tùy chọn*) : Tên index elasticsearch được sử dụng để tạo index. es_index_config (`dict`, *tùy chọn*) : Cấu hình của chỉ mục elasticsearch. Cấu hình mặc định là: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Thêm một chỉ mục văn bản bằng ElasticSearch để truy xuất nhanh. Thao tác này được thực hiện tại chỗ. Ví dụ: ```python >>> es_client = elasticsearch.Elasticsearch() >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> ds.add_elasticsearch_index(column='line', es_client=es_client, es_index_name="my_es_index") >>> scores, retrieved_examples = ds.get_nearest_examples('line', 'my new query', k=10) ``` #### load_elasticsearch_index[[datasets.Dataset.load_elasticsearch_index]] ```python load_elasticsearch_index(index_name: str, es_index_name: str, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('Elasticsearch')] = None, es_index_config: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L637) **Tham số:** index_name (`str`) : `index_name`/định danh của chỉ mục. Đây là tên chỉ mục được dùng để gọi `get_nearest` hoặc `search`. es_index_name (`str`) : Tên của index elasticsearch cần tải. host (`str`, *tùy chọn*, mặc định là `localhost`) : Máy chủ nơi ElasticSearch đang chạy. port (`str`, *tùy chọn*, mặc định là `9200`) : Cổng nơi ElasticSearch đang chạy. es_client (`elasticsearch.Elasticsearch`, *tùy chọn*) : Client elasticsearch được sử dụng để tạo index nếu host và port là `None`. es_index_config (`dict`, *tùy chọn*) : Cấu hình của chỉ mục elasticsearch. Cấu hình mặc định là: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Tải một chỉ mục văn bản hiện có bằng ElasticSearch để truy xuất nhanh. #### list_indexes[[datasets.Dataset.list_indexes]] ```python list_indexes() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L438) Liệt kê `colindex_nameumns`/định danh của tất cả các chỉ mục đã gắn. #### get_index[[datasets.Dataset.get_index]] ```python get_index(index_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L442) **Tham số:** index_name (`str`) : Tên chỉ mục. **Trả về:** `BaseIndex` Liệt kê `index_name`/định danh của tất cả các chỉ mục đã gắn. #### drop_index[[datasets.Dataset.drop_index]] ```python drop_index(index_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L684) **Tham số:** index_name (`str`) : `index_name`/định danh của chỉ mục. Xóa chỉ mục với cột được chỉ định. #### tìm kiếm[[datasets.Dataset.search]] ```python search(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L693) **Tham số:** index_name (`str`) : Tên/định danh của chỉ mục. query (`Union[str, np.ndarray]`) : Truy vấn dưới dạng chuỗi nếu `index_name` là chỉ mục văn bản hoặc dưới dạng mảng numpy nếu `index_name` là chỉ mục vector. k (`int`) : Số lượng ví dụ cần lấy. **Trả về:** `(scores, indices)` Một tuple của `(scores, indices)` trong đó: - **scores** (`List[List[float]`): điểm truy xuất từ FAISS (mặc định là `IndexFlatL2`) hoặc ElasticSearch của các ví dụ đã được truy xuất - **indices** (`List[List[int]]`): các chỉ số của các ví dụ đã được truy xuất Tìm các chỉ mục của các ví dụ gần nhất trong bộ dữ liệu so với truy vấn. #### search_batch[[datasets.Dataset.search_batch]] ```python search_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L713) **Tham số:** index_name (`str`) : `index_name`/định danh của chỉ mục. queries (`Union[List[str], np.ndarray]`) : Các truy vấn dưới dạng danh sách các chuỗi nếu `index_name` là chỉ mục văn bản hoặc dưới dạng mảng numpy nếu `index_name` là chỉ mục vector. k (`int`) : Số lượng ví dụ cần lấy cho mỗi truy vấn. **Trả về:** `(total_scores, total_indices)` Một tuple của `(total_scores, total_indices)` trong đó: - **total_scores** (`List[List[float]`): điểm truy xuất từ FAISS (mặc định là `IndexFlatL2`) hoặc ElasticSearch của các ví dụ được truy xuất cho mỗi truy vấn - **total_indices** (`List[List[int]]`): các chỉ số của các ví dụ được truy xuất cho mỗi truy vấn Tìm các chỉ mục của các ví dụ gần nhất trong bộ dữ liệu so với truy vấn. #### get_nearest_examples[[datasets.Dataset.get_nearest_examples]] ```python get_nearest_examples(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L735) **Tham số:** index_name (`str`) : index_name/định danh của index. query (`Union[str, np.ndarray]`) : Truy vấn dưới dạng chuỗi nếu `index_name` là chỉ mục văn bản hoặc dưới dạng mảng numpy nếu `index_name` là chỉ mục vector. k (`int`) : Số lượng ví dụ cần lấy. **Trả về:** `(scores, examples)` Một tuple của `(scores, examples)` trong đó: - **scores** (`List[float]`): điểm truy xuất từ FAISS (mặc định là `IndexFlatL2`) hoặc ElasticSearch của các ví dụ đã được truy xuất - **examples** (`dict`): các ví dụ đã được truy xuất Tìm các ví dụ gần nhất trong bộ dữ liệu so với truy vấn. #### get_nearest_examples_batch[[datasets.Dataset.get_nearest_examples_batch]] ```python get_nearest_examples_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L759) **Tham số:** index_name (`str`) : `index_name`/định danh của chỉ mục. queries (`Union[List[str], np.ndarray]`) : Các truy vấn dưới dạng danh sách các chuỗi nếu `index_name` là chỉ mục văn bản hoặc dưới dạng mảng numpy nếu `index_name` là chỉ mục vector. k (`int`) : Số lượng ví dụ cần lấy cho mỗi truy vấn. **Trả về:** `(total_scores, total_examples)` Một tuple của `(total_scores, total_examples)` trong đó: - **total_scores** (`List[List[float]`): điểm truy xuất từ FAISS (mặc định là `IndexFlatL2`) hoặc ElasticSearch của các ví dụ được truy xuất cho mỗi truy vấn - **total_examples** (`List[dict]`): các ví dụ được truy xuất cho mỗi truy vấn Tìm các ví dụ gần nhất trong bộ dữ liệu so với truy vấn. #### info[[datasets.Dataset.info]] ```python info() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L172) đối tượng [DatasetInfo](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetInfo) chứa tất cả các metadata trong dataset. #### split[[datasets.Dataset.split]] ```python split() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L177) đối tượng [NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit) tương ứng với một phần chia (split) có tên của tập dữ liệu. #### builder_name[[datasets.Dataset.builder_name]] ```python builder_name() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L182) #### trích dẫn[[datasets.Dataset.citation]] ```python citation() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.Dataset.config_name]] ```python config_name() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.Dataset.dataset_size]] ```python dataset_size() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L194) #### mô tả[[datasets.Dataset.description]] ```python description() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.Dataset.download_checksums]] ```python download_checksums() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.Dataset.download_size]] ```python download_size() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L206) #### tính năng[[datasets.Dataset.features]] ```python features() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L785) #### Trang chủ[[datasets.Dataset.homepage]] ```python homepage() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L214) #### Giấy phép[[datasets.Dataset.license]] ```python license() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.Dataset.size_in_bytes]] ```python size_in_bytes() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.Dataset.supervised_keys]] ```python supervised_keys() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L226) #### phiên bản[[datasets.Dataset.version]] ```python version() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L230) #### from_csv[[datasets.Dataset.from_csv]] ```python from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1282) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp CSV. split ([NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit), *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình khi tải xuống và tạo bộ dữ liệu cục bộ. Điều này hữu ích nếu bộ dữ liệu được tạo từ nhiều tệp. Xử lý đa tiến trình bị vô hiệu hóa theo mặc định. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `pandas.read_csv`. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo Dataset từ tệp CSV. Đọc các tệp CSV, lưu trữ dữ liệu vào bộ nhớ đệm trên đĩa ở định dạng Arrow và trả về Dataset từ dữ liệu Arrow được ánh xạ bộ nhớ trên đĩa. Ví dụ: ```py >>> ds = Dataset.from_csv('path/to/dataset.csv') ``` #### from_json[[datasets.Dataset.from_json]] ```python from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, num_proc: typing.Optional[int] = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1422) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp JSON hoặc JSON Lines. split ([NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit), *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. field (`str`, *tùy chọn*) : Tên trường của tệp JSON chứa bộ dữ liệu. num_proc (`int`, *tuỳ chọn* mặc định là `None`) : Số lượng tiến trình khi tải xuống và tạo bộ dữ liệu cục bộ. Điều này hữu ích nếu bộ dữ liệu được tạo từ nhiều tệp. Xử lý đa tiến trình bị vô hiệu hóa theo mặc định. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `JsonConfig`. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo Dataset từ tệp JSON hoặc JSON Lines. Đọc các tệp JSON, lưu trữ bộ nhớ đệm dữ liệu ở định dạng Arrow trên đĩa và trả về Dataset từ dữ liệu Arrow được ánh xạ bộ nhớ trên đĩa. Ví dụ: ```py >>> ds = Dataset.from_json('path/to/dataset.json') ``` #### from_parquet[[datasets.Dataset.from_parquet]] ```python from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, num_proc: typing.Optional[int] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1481) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp Parquet. split (`NamedSplit`, *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features (`Features`, *tùy chọn*) : Các đặc trưng của tập dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. columns (`List[str]`, *tùy chọn*) : Nếu không phải `None`, chỉ các cột này sẽ được đọc từ tệp. Tên cột có thể là tiền tố của một trường lồng nhau, ví dụ 'a' sẽ chọn 'a.b', 'a.c' và 'a.d.e'. num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình khi tải xuống và tạo bộ dữ liệu cục bộ. Điều này hữu ích nếu bộ dữ liệu được tạo từ nhiều tệp. Xử lý đa tiến trình bị vô hiệu hóa theo mặc định. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *tùy chọn*) : Chỉ trả về các dòng khớp với bộ lọc. Nếu có thể, điều kiện sẽ được đẩy xuống để khai thác thông tin phân vùng hoặc siêu dữ liệu bên trong tìm thấy trong nguồn dữ liệu, ví dụ như thống kê Parquet. Nếu không, bộ lọc sẽ được áp dụng lên các RecordBatch đã tải trước khi chúng được trả về. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *tuỳ chọn*) : Các tuỳ chọn quét cụ thể cho các fragment Parquet. Điều này đặc biệt hữu ích để cấu hình đệm và bộ nhớ đệm. on_bad_files (`Literal["error", "warn", "skip"]`, *tùy chọn*, mặc định là "error") : Xác định cách xử lý khi gặp tệp lỗi (tệp không thể đọc được). Các giá trị được phép là : * 'error', ném một Exception khi gặp tệp lỗi. * 'warn', phát sinh một cảnh báo khi gặp tệp lỗi và bỏ qua tệp đó. * 'skip', bỏ qua các tệp lỗi mà không phát sinh ngoại lệ hay cảnh báo khi gặp chúng. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `ParquetConfig`. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo Dataset từ tệp Parquet. Đọc các tệp Parquet, lưu trữ bộ đệm dữ liệu ở định dạng Arrow trên đĩa và trả về Dataset từ dữ liệu Arrow được ánh xạ bộ nhớ trên đĩa. Ví dụ: ```py >>> ds = Dataset.from_parquet('path/to/dataset.parquet') ``` Tải một tập con các cột: ```python >>> ds = Dataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Lọc dữ liệu một cách hiệu quả, có thể bỏ qua toàn bộ các tệp hoặc nhóm hàng: ```python >>> filters = [("col_0", "==", 0)] >>> ds = Dataset.from_parquet(parquet_files_list, filters=filters) ``` #### from_text[[datasets.Dataset.from_text]] ```python from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1578) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp văn bản. split (`NamedSplit`, *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features (`Features`, *tùy chọn*) : Các đặc trưng của tập dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình khi tải xuống và tạo bộ dữ liệu cục bộ. Điều này hữu ích nếu bộ dữ liệu được tạo từ nhiều tệp. Xử lý đa tiến trình bị vô hiệu hóa theo mặc định. keep_linebreaks : (`bool`, mặc định là False): Có giữ xuống dòng hay không. sample_by (`Literal["line", "paragraph", "document"]`, mặc định là "line") : Xác định việc nạp dữ liệu theo từng dòng, đoạn văn hay tài liệu. Mặc định, một hàng trong bộ dữ liệu tương ứng với một dòng. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `TextConfig`. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo Dataset từ tệp văn bản. Đọc các tệp văn bản, lưu trữ bộ nhớ đệm dữ liệu ở định dạng Arrow trên đĩa và trả về Dataset từ dữ liệu Arrow được ánh xạ bộ nhớ trên đĩa. Ví dụ: ```py >>> ds = Dataset.from_text('path/to/dataset.txt') ``` #### from_sql[[datasets.Dataset.from_sql]] ```python from_sql(sql: typing.Union[str, ForwardRef('sqlalchemy.sql.Selectable')], con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1706) **Tham số:** sql (`str` hoặc `sqlalchemy.sql.Selectable`) : truy vấn SQL cần thực thi hoặc tên bảng. con (`str` hoặc `sqlite3.Connection` hoặc `sqlalchemy.engine.Connection` hoặc `sqlalchemy.engine.Connection`) : Một [chuỗi URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) được sử dụng để khởi tạo kết nối cơ sở dữ liệu hoặc một đối tượng kết nối SQLite3/SQLAlchemy. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `SqlConfig`. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) Tạo Dataset từ truy vấn SQL hoặc bảng cơ sở dữ liệu. Truy vấn cơ sở dữ liệu SQL, lưu trữ dữ liệu đệm trên đĩa ở định dạng Arrow và trả về Dataset từ dữ liệu Arrow được ánh xạ bộ nhớ trên đĩa. Ví dụ: ```py >>> # Fetch a database table >>> ds = Dataset.from_sql("test_data", "postgres:///db_name") >>> # Execute a SQL query on the table >>> ds = Dataset.from_sql("SELECT sentence FROM test_data", "postgres:///db_name") >>> # Use a Selectable object to specify the query >>> from sqlalchemy import select, text >>> stmt = select([text("sentence")]).select_from(text("test_data")) >>> ds = Dataset.from_sql(stmt, "postgres:///db_name") ``` > [!TIP] > Bộ dữ liệu được trả về chỉ có thể được lưu vào bộ nhớ đệm nếu `con` được chỉ định dưới dạng chuỗi URI. #### align_labels_with_mapping[[datasets.Dataset.align_labels_with_mapping]] ```python align_labels_with_mapping(label2id: dict, label_column: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6588) **Tham số:** label2id (`dict`) : Bản ánh xạ từ tên nhãn sang ID để căn chỉnh bộ dữ liệu. label_column (`str`) : Tên cột của nhãn để căn chỉnh. Căn chỉnh ánh xạ ID nhãn và tên nhãn của bộ dữ liệu để khớp với ánh xạ `label2id` đầu vào. Điều này hữu ích khi bạn muốn đảm bảo rằng các nhãn dự đoán của mô hình được căn chỉnh với bộ dữ liệu. Việc căn chỉnh được thực hiện bằng cách sử dụng tên nhãn viết thường. Ví dụ: ```python >>> # dataset with mapping {'entailment': 0, 'neutral': 1, 'contradiction': 2} >>> ds = load_dataset("nyu-mll/glue", "mnli", split="train") >>> # mapping to align with >>> label2id = {'CONTRADICTION': 0, 'NEUTRAL': 1, 'ENTAILMENT': 2} >>> ds_aligned = ds.align_labels_with_mapping(label2id, "label") ``` #### datasets.concatenate_datasets[[datasets.concatenate_datasets]] ```python datasets.concatenate_datasets(dsets: list, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, axis: int = 0) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/combine.py#L168) **Tham số:** dsets (`List[datasets.Dataset]` hoặc `List[datasets.IterableDataset]`) : Danh sách các Datasets cần nối. info (`DatasetInfo`, *tùy chọn*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, *tùy chọn*) : Tên của phần chia bộ dữ liệu. axis (`{0, 1}`, mặc định là `0`) : Trục để ghép nối, trong đó `0` có nghĩa là theo hàng (theo chiều dọc) và `1` có nghĩa là theo cột (theo chiều ngang). Nối nhiều bộ dữ liệu (nguồn) thành một bộ dữ liệu duy nhất. Sử dụng axis=0 để ghép dọc (mặc định), hoặc axis=1 để ghép ngang. Lưu ý dành cho các tập dữ liệu dạng lặp: * nếu axis=0, `num_shards` của dataset kết quả là tổng `num_shards` của từng dataset. * nếu axis=1, tập dữ liệu kết quả sẽ có một (1) shard để không làm lệch dữ liệu. * nếu các bộ dữ liệu được chia bằng [datasets.distributed.split_dataset_by_node()](/docs/datasets/main/vi/package_reference/main_classes#datasets.distributed.split_dataset_by_node), tất cả chúng phải được chia theo cùng một cách, và bộ dữ liệu kết quả sẽ giữ nguyên cách chia đó. Ví dụ: ```py >>> ds3 = concatenate_datasets([ds1, ds2]) ``` #### datasets.interleave_datasets[[datasets.interleave_datasets]] ```python datasets.interleave_datasets(datasets: list, probabilities: typing.Optional[list[float]] = None, seed: typing.Optional[int] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, stopping_strategy: typing.Literal['first_exhausted', 'all_exhausted', 'all_exhausted_without_replacement'] = 'first_exhausted') ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/combine.py#L18) **Tham số:** datasets (`List[Dataset]` hoặc `List[IterableDataset]`) : Danh sách các dataset để xen kẽ. probabilities (`List[float]`, *tùy chọn*, mặc định là `None`) : Nếu được chỉ định, tập dữ liệu mới sẽ được xây dựng bằng cách lấy mẫu các ví dụ từ một nguồn tại một thời điểm theo các xác suất này. seed (`int`, *tuỳ chọn*, mặc định là `None`) : Hạt ngẫu nhiên được sử dụng để chọn một nguồn cho mỗi ví dụ. info ([DatasetInfo](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetInfo), *optional*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split ([NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit), *tùy chọn*) : Tên của phần chia bộ dữ liệu. stopping_strategy (`str`, mặc định là `first_exhausted`) : Hiện tại có ba chiến lược được đề xuất, `first_exhausted`, `all_exhausted` và `all_exhausted_without_replacement`. Mặc định, `first_exhausted` là chiến lược lấy mẫu thiếu (undersampling), tức là quá trình xây dựng tập dữ liệu sẽ dừng lại ngay khi một tập dữ liệu hết mẫu. Nếu chiến lược là `all_exhausted`, chúng ta sử dụng chiến lược lấy mẫu thừa (oversampling), tức là quá trình xây dựng tập dữ liệu sẽ dừng lại ngay khi mọi mẫu của mọi tập dữ liệu đã được thêm vào ít nhất một lần. Khi chiến lược là `all_exhausted_without_replacement`, chúng ta đảm bảo rằng mỗi mẫu trong mỗi tập dữ liệu chỉ được lấy mẫu một lần. Lưu ý rằng nếu chiến lược là `all_exhausted`, kích thước của tập dữ liệu xen kẽ có thể trở nên rất lớn: - nếu không có xác suất, tập dữ liệu kết quả sẽ có `max_length_datasets*nb_dataset` mẫu. - nếu có xác suất được cho trước, tập dữ liệu kết quả sẽ có nhiều mẫu hơn nếu một số tập dữ liệu có xác suất được truy cập thực sự thấp. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) hoặc [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Kiểu trả về phụ thuộc vào tham số `datasets` đầu vào. `Dataset` nếu đầu vào là một danh sách `Dataset`, `IterableDataset` nếu đầu vào là một danh sách `IterableDataset`. Ghép xen kẽ nhiều bộ dữ liệu (nguồn) thành một bộ dữ liệu duy nhất. Bộ dữ liệu mới được xây dựng bằng cách luân phiên lấy các ví dụ từ các nguồn. Bạn có thể sử dụng hàm này trên một danh sách các đối tượng [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset), hoặc trên một danh sách các đối tượng [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset). - Nếu `probabilities` là `None` (mặc định), tập dữ liệu mới được xây dựng bằng cách luân phiên giữa từng nguồn để lấy các ví dụ. - Nếu `probabilities` không phải là `None`, tập dữ liệu mới sẽ được xây dựng bằng cách lấy các ví dụ từ một nguồn ngẫu nhiên một lần một theo các xác suất được cung cấp. Bộ dữ liệu kết quả sẽ kết thúc khi một trong các bộ dữ liệu nguồn hết ví dụ, ngoại trừ khi `oversampling` là `True`, trong trường hợp đó, bộ dữ liệu kết quả sẽ kết thúc khi tất cả các bộ dữ liệu đã hết ví dụ ít nhất một lần. Lưu ý dành cho các tập dữ liệu dạng lặp: * Giá trị `num_shards` của dataset kết quả là giá trị nhỏ nhất trong số các `num_shards` của từng dataset để đảm bảo khả năng song song hóa tốt. Nếu một số dataset của bạn có số lượng shard rất thấp, bạn có thể sử dụng [IterableDataset.reshard()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.reshard). * Trong cấu hình phân tán hoặc trong các worker của PyTorch DataLoader, chiến lược dừng được áp dụng cho từng tiến trình. Do đó, chiến lược "first_exhausted" trên một tập dữ liệu lặp lại dạng sharded có thể tạo ra ít mẫu hơn về tổng số (tối đa 1 mẫu bị thiếu cho mỗi tập dữ liệu con cho mỗi worker). Ví dụ: Đối với các bộ dữ liệu thông thường (kiểu map): ```python >>> from datasets import Dataset, interleave_datasets >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22]}) >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 10, 0, 1, 2, 21, 0, 11, 1, 2, 0, 1, 12, 2, 10, 0, 22] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12, 13]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22, 23, 24]}) >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22, 0, 13, 23, 1, 10, 24] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 13, ..., 0, 1, 2, 0, 24] For datasets in streaming mode (iterable): >>> from datasets import interleave_datasets >>> d1 = load_dataset('allenai/c4', 'es', split='train', streaming=True) >>> d2 = load_dataset('allenai/c4', 'fr', split='train', streaming=True) >>> dataset = interleave_datasets([d1, d2]) >>> iterator = iter(dataset) >>> next(iterator) {'text': 'Comprar Zapatillas para niña en chancla con goma por...'} >>> next(iterator) {'text': 'Le sacre de philippe ier, 23 mai 1059 - Compte Rendu...' ``` #### datasets.distributed.split_dataset_by_node[[datasets.distributed.split_dataset_by_node]] ```python datasets.distributed.split_dataset_by_node(dataset: ~DatasetType, rank: int, world_size: int, strategy: typing.Literal['auto', 'shards', 'examples'] = 'auto') ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/distributed.py#L10) **Tham số:** dataset ([Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) hoặc [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset)) : Bộ dữ liệu cần chia theo nút. rank (`int`) : Bậc của nút hiện tại. world_size (`int`) : Tổng số nút. strategy (`str`, mặc định là `"auto"`) : Cách chia một tập dữ liệu dạng lặp. Phải là một trong `"auto"`, `"shards"` hoặc `"examples"`. Các tập dữ liệu dạng map chỉ hỗ trợ `"auto"`. **Trả về:** [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) hoặc [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Bộ dữ liệu sẽ được sử dụng trên nút có rank `rank`. Tách một tập dữ liệu cho nút có thứ hạng `rank` trong một nhóm các nút có kích thước `world_size`. Đối với các bộ dữ liệu theo phong cách map: Mỗi node được gán một phần dữ liệu, ví dụ rank 0 nhận phần đầu tiên của tập dữ liệu. Để tối đa hóa thông lượng nạp dữ liệu, các phần dữ liệu được tạo từ dữ liệu liên tục trên đĩa nếu có thể. Đối với các tập dữ liệu có thể lặp lại: Chiến lược `strategy` phân tách có thể là `"auto"`, `"shards"` hoặc `"examples"`: * `"shards"`: các shard được phân bổ đều giữa các node * `"examples"`: mỗi nút giữ lại 1 ví dụ trong số `world_size`, bỏ qua các ví dụ còn lại * `"auto"` (mặc định): sử dụng `"shards"` nếu số lượng shards của dataset là một ước số của `world_size` (tức là nếu `dataset.num_shards % world_size == 0`), đây là trường hợp được tối ưu nhất. Ngược lại, sẽ sử dụng `"examples"`. > [!WARNING] > Nếu bạn xáo trộn bộ dữ liệu lặp được (iterable dataset) trong một cấu hình phân tán, hãy đảm bảo đặt một `seed` cố định trong [IterableDataset.shuffle()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.shuffle) do đó cùng một danh sách shard đã được xáo trộn được sử dụng trên mọi node để biết node nên bỏ qua những shard nào. #### datasets.enable_caching[[datasets.enable_caching]] ```python datasets.enable_caching() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L120) Khi áp dụng các phép biến đổi lên một tập dữ liệu, dữ liệu sẽ được lưu trữ trong các tệp cache. Cơ chế cache cho phép nạp lại một tệp cache hiện có nếu nó đã được tính toán trước đó. Việc tải lại một tập dữ liệu là khả thi vì các tệp cache được đặt tên dựa trên dấu vân tay của tập dữ liệu, và dấu vân tay này được cập nhật sau mỗi lần biến đổi. Nếu bị vô hiệu hóa, thư viện sẽ không còn nạp lại các tệp dữ liệu tập được lưu trong bộ nhớ đệm khi áp dụng các phép biến đổi lên các tập dữ liệu. Cụ thể hơn, nếu việc lưu bộ nhớ đệm bị vô hiệu hóa: - các tệp cache luôn được tạo lại - các tệp cache được ghi vào một thư mục tạm, thư mục này sẽ bị xóa khi phiên kết thúc - các tệp cache được đặt tên bằng một băm ngẫu nhiên thay vì dấu vân tay của bộ dữ liệu - Sử dụng [save_to_disk()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.save_to_disk) để lưu bộ dữ liệu đã biến đổi, nếu không nó sẽ bị xóa khi phiên làm việc kết thúc - caching không ảnh hưởng đến [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset). Nếu bạn muốn tạo lại một dataset từ đầu, bạn nên sử dụng tham số `download_mode` trong [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset). #### datasets.disable_caching[[datasets.disable_caching]] ```python datasets.disable_caching() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L141) Khi áp dụng các phép biến đổi lên một tập dữ liệu, dữ liệu sẽ được lưu trữ trong các tệp cache. Cơ chế cache cho phép nạp lại một tệp cache hiện có nếu nó đã được tính toán trước đó. Việc tải lại một tập dữ liệu là khả thi vì các tệp cache được đặt tên dựa trên dấu vân tay của tập dữ liệu, và dấu vân tay này được cập nhật sau mỗi lần biến đổi. Nếu bị vô hiệu hóa, thư viện sẽ không còn nạp lại các tệp dữ liệu tập được lưu trong bộ nhớ đệm khi áp dụng các phép biến đổi lên các tập dữ liệu. Cụ thể hơn, nếu việc lưu bộ nhớ đệm bị vô hiệu hóa: - các tệp cache luôn được tạo lại - các tệp cache được ghi vào một thư mục tạm, thư mục này sẽ bị xóa khi phiên kết thúc - các tệp cache được đặt tên bằng một băm ngẫu nhiên thay vì dấu vân tay của bộ dữ liệu - Sử dụng [save_to_disk()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.save_to_disk) để lưu bộ dữ liệu đã biến đổi, nếu không nó sẽ bị xóa khi phiên làm việc kết thúc - caching không ảnh hưởng đến [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset). Nếu bạn muốn tạo lại một dataset từ đầu, bạn nên sử dụng tham số `download_mode` trong [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset). #### datasets.is_caching_enabled[[datasets.is_caching_enabled]] ```python datasets.is_caching_enabled() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L162) Khi áp dụng các phép biến đổi lên một tập dữ liệu, dữ liệu sẽ được lưu trữ trong các tệp cache. Cơ chế cache cho phép nạp lại một tệp cache hiện có nếu nó đã được tính toán trước đó. Việc tải lại một tập dữ liệu là khả thi vì các tệp cache được đặt tên dựa trên dấu vân tay của tập dữ liệu, và dấu vân tay này được cập nhật sau mỗi lần biến đổi. Nếu bị vô hiệu hóa, thư viện sẽ không còn nạp lại các tệp dữ liệu tập được lưu trong bộ nhớ đệm khi áp dụng các phép biến đổi lên các tập dữ liệu. Cụ thể hơn, nếu việc lưu bộ nhớ đệm bị vô hiệu hóa: - các tệp cache luôn được tạo lại - các tệp cache được ghi vào một thư mục tạm, thư mục này sẽ bị xóa khi phiên kết thúc - các tệp cache được đặt tên bằng một băm ngẫu nhiên thay vì dấu vân tay của bộ dữ liệu - sử dụng [save_to_disk()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.save_to_disk)] để lưu bộ dữ liệu đã biến đổi, nếu không nó sẽ bị xóa khi phiên làm việc kết thúc - caching không ảnh hưởng đến [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset). Nếu bạn muốn tạo lại một dataset từ đầu, bạn nên sử dụng tham số `download_mode` trong [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset). #### datasets.Column[[datasets.Column]] ```python datasets.Column(source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')], column_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L638) Một đối tượng lặp được cho một cột cụ thể của [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset). Ví dụ: Lặp lại trên các văn bản của cột "text" của một tập dữ liệu: ```python for text in dataset["text"]: ... ``` Nó cũng hoạt động với các cột lồng nhau: ```python for source in dataset["metadata"]["source"]: ... ``` ## DatasetDict[[datasets.DatasetDict]] Từ điển có tên các phần chia làm khóa (ví dụ 'train', 'test') và các đối tượng `Dataset` làm giá trị. Nó cũng có các phương thức biến đổi tập dữ liệu như map hoặc filter, để xử lý tất cả các phần chia cùng lúc. #### datasets.DatasetDict[[datasets.DatasetDict]] [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L53) Một từ điển (dict của str: datasets.Dataset) chứa các phương thức biến đổi tập dữ liệu (map, filter, v.v.) #### data[[datasets.DatasetDict.data]] ```python data() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L94) Các bảng Apache Arrow hỗ trợ cho mỗi phần chia (split). Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.data ``` #### cache_files[[datasets.DatasetDict.cache_files]] ```python cache_files() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L109) Các tệp cache chứa bảng Apache Arrow hỗ trợ cho mỗi phần chia (split). Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.cache_files {'test': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-test.arrow'}], 'train': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-train.arrow'}], 'validation': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}]} ``` #### num_columns[[datasets.DatasetDict.num_columns]] ```python num_columns() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L127) Số cột trong mỗi phần chia của bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.num_columns {'test': 2, 'train': 2, 'validation': 2} ``` #### num_rows[[datasets.DatasetDict.num_rows]] ```python num_rows() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L143) Số dòng trong mỗi phần chia của bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.num_rows {'test': 1066, 'train': 8530, 'validation': 1066} ``` #### column_names[[datasets.DatasetDict.column_names]] ```python column_names() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L159) Tên của các cột trong mỗi phần chia của bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.column_names {'test': ['text', 'label'], 'train': ['text', 'label'], 'validation': ['text', 'label']} ``` #### shape[[datasets.DatasetDict.shape]] ```python shape() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L177) Hình dạng của mỗi phần chia của bộ dữ liệu (số hàng, số cột). Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.shape {'test': (1066, 2), 'train': (8530, 2), 'validation': (1066, 2)} ``` #### unique[[datasets.DatasetDict.unique]] ```python unique(column: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L226) **Tham số:** column (`str`) : tên cột (liệt kê tất cả tên cột bằng [column_names](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict.column_names)) **Trả về:** Dict[`str`, `list`] Từ điển các phần tử duy nhất trong cột đã cho. Trả về danh sách các phần tử duy nhất trong một cột cho mỗi phần chia. Điều này được triển khai trong backend cấp thấp và do đó, rất nhanh. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.unique("label") {'test': [1, 0], 'train': [1, 0], 'validation': [1, 0]} ``` #### cleanup_cache_files[[datasets.DatasetDict.cleanup_cache_files]] ```python cleanup_cache_files() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L250) **Trả về:** `Dict` chứa số lượng tệp đã bị xóa cho mỗi split Dọn dẹp tất cả các tệp cache trong thư mục cache của dataset, ngoại trừ tệp cache đang được sử dụng (nếu có). Hãy cẩn thận khi chạy lệnh này để đảm bảo không có tiến trình nào khác đang sử dụng các tệp cache khác. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.cleanup_cache_files() {'test': 0, 'train': 0, 'validation': 0} ``` #### map[[datasets.DatasetDict.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L814) **Tham số:** function (`callable`) : với một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> Dict[str, Any]` nếu `batched=False` và `with_indices=False` - `function(example: Dict[str, Any], indices: int) -> Dict[str, Any]` nếu `batched=False` và `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` nếu `batched=True` và `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` nếu `batched=True` và `with_indices=True` Đối với việc sử dụng nâng cao, hàm cũng có thể trả về một `pyarrow.Table`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song. Hơn nữa, nếu hàm của bạn không trả về gì (`None`), thì `map` sẽ chạy hàm của bạn và trả về tập dữ liệu không thay đổi. Nếu không cung cấp hàm, mặc định là hàm đồng nhất: `lambda x: x`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx): ...`. with_rank (`bool`, mặc định là `False`) : Cung cấp thứ tự tiến trình cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example[, idx], rank): ...`. with_split (`bool`, mặc định là `False`) : Cung cấp process split cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example[, idx], split): ...`. input_columns (`[Union[str, list[str]]]`, *tùy chọn*, mặc định là `None`) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một dict ánh xạ đến tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function`. batch_size (`int`, *tuỳ chọn*, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched=True`, `batch_size <= 0` hoặc `batch_size == None` thì cung cấp toàn bộ tập dữ liệu như một batch duy nhất cho `function`. drop_last_batch (`bool`, mặc định là `False`) : Xác định xem một batch cuối nhỏ hơn batch_size có nên bị loại bỏ thay vì được xử lý bởi hàm hay không. remove_columns (`[Union[str, list[str]]]`, *tùy chọn*, mặc định là `None`) : Loại bỏ một tập các cột trong khi thực hiện ánh xạ. Các cột sẽ bị loại bỏ trước khi cập nhật các ví dụ bằng đầu ra của `function`, tức là nếu `function` thêm các cột có tên nằm trong `remove_columns`, các cột này sẽ được giữ lại. keep_in_memory (`bool`, mặc định là `False`) : Giữ bộ dữ liệu trong bộ nhớ thay vì ghi nó vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ kết quả tính toán hiện tại của `function`, hãy sử dụng tệp đó thay vì tính toán lại. cache_file_names (`[Dict[str, str]]`, *tùy chọn*, mặc định là `None`) : Cung cấp tên của một đường dẫn cho tệp cache. Nó được dùng để lưu trữ kết quả của phép tính thay vì tên tệp cache được tạo tự động. Bạn phải cung cấp một `cache_file_name` cho mỗi dataset trong từ điển dataset. writer_batch_size (`int`, mặc định `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. features (`[datasets.Features]`, *tùy chọn*, mặc định là `None`) : Sử dụng một [Features](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features) cụ thể để lưu tệp cache thay vì tệp được tạo tự động. disable_nullable (`bool`, mặc định là `False`) : Không cho phép các giá trị null trong bảng. fn_kwargs (`Dict`, *tùy chọn*, mặc định là `None`) : Các đối số từ khóa để truyền cho `function` num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình cần sử dụng cho đa tiến trình. - Nếu là `None` hoặc `0`, sẽ không sử dụng đa tiến trình và thao tác được thực thi trong tiến trình chính. - Nếu lớn hơn `1`, một hoặc nhiều tiến trình worker sẽ được sử dụng để xử lý dữ liệu song song. Lưu ý: Hàm được truyền vào `map()` phải có thể picklable để đa tiến trình hoạt động chính xác (tức là nên ưu tiên các hàm được định nghĩa ở cấp độ trên cùng của một module, thay vì bên trong một hàm hoặc lớp khác). desc (`str`, *tùy chọn*, mặc định là `None`) : Mô tả có ý nghĩa để hiển thị cùng với thanh tiến trình trong khi ánh xạ các ví dụ. try_original_type (`Optional[bool]`, mặc định là `True`) : Cố gắng giữ nguyên kiểu dữ liệu của các cột gốc (ví dụ: int32 -> int32). Đặt thành False nếu bạn muốn luôn suy luận các kiểu dữ liệu mới. on_mixed_types (`Literal["use_json"]`, *tùy chọn*, mặc định là `None`) : Nếu là "use_json", hãy sử dụng kiểu Json() cho các trường có kiểu dữ liệu hỗn hợp, tức là các trường không có cấu trúc chứa dữ liệu không có schema được định nghĩa trước. Trong trường hợp này, một trường có kiểu hỗn hợp sẽ được đặt thành Json(). Điều này cho phép nạp các danh sách chứa hỗn hợp chuỗi/số nguyên/số thực, chẳng hạn, hoặc các từ điển có kiểu giá trị tùy ý. Áp dụng một hàm cho tất cả các ví dụ trong bảng (riêng lẻ hoặc theo lô) và cập nhật bảng. Nếu hàm của bạn trả về một cột đã tồn tại, thì nó sẽ ghi đè lên cột đó. Phép biến đổi được áp dụng cho tất cả các tập dữ liệu của từ điển tập dữ liệu. Bạn có thể chỉ định xem hàm có nên được xử lý theo lô (batched) hay không bằng tham số `batched`: - Nếu `False`, thì hàm nhận vào 1 ví dụ và phải trả về 1 ví dụ. Một ví dụ là một từ điển, ví dụ `{"text": "Hello there !"}`. - Nếu `True` và `batch_size` là 1, thì hàm nhận vào một batch gồm 1 ví dụ và có thể trả về một batch gồm 1 hoặc nhiều hơn các ví dụ. Một batch là một từ điển, ví dụ một batch gồm 1 ví dụ là `{"text": ["Hello there !"]}`. - Nếu `True` và `batch_size` là `n > 1`, thì hàm nhận vào một batch gồm `n` ví dụ và có thể trả về một batch gồm `n` ví dụ, hoặc một số lượng ví dụ bất kỳ. Lưu ý rằng batch cuối cùng có thể có ít hơn `n` ví dụ. Một batch là một từ điển, ví dụ một batch gồm `n` ví dụ là `{"text": ["Hello there !"] * n}`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song, với tối đa một nghìn cuộc gọi đồng thời. Khuyến nghị sử dụng `asyncio.Semaphore` trong hàm của bạn nếu bạn muốn đặt số lượng tối đa các thao tác có thể chạy cùng lúc. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds["train"][0:3]["text"] ['Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .', 'Review: effective but too-tepid biopic'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4) ``` #### lọc[[datasets.DatasetDict.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L986) **Tham số:** function (`Callable`) : Callable có một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> bool` nếu `batched=False` và `with_indices=False` và `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` nếu `batched=False` và `with_indices=True` và/hoặc `with_rank=True` (mỗi tham số thêm một đối số) - `function(batch: Dict[str, list]) -> list[bool]` nếu `batched=True` và `with_indices=False` và `with_rank=False` - `function(batch: Dict[str, list], *extra_args) -> list[bool]` nếu `batched=True` và `with_indices=True` và/hoặc `with_rank=True` (mỗi tham số thêm một đối số) Nếu không cung cấp hàm nào, mặc định là hàm luôn trả về `True`: `lambda x: True`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx[, rank]): ...`. with_rank (`bool`, mặc định là `False`) : Cung cấp thứ tự tiến trình cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example[, idx], rank): ...`. input_columns (`[Union[str, list[str]]]`, *tùy chọn*, mặc định là `None`) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một dict ánh xạ đến tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function`. batch_size (`int`, *tuỳ chọn*, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched=True` `batch_size <= 0` hoặc `batch_size == None` thì cung cấp toàn bộ tập dữ liệu như một batch duy nhất cho `function`. keep_in_memory (`bool`, mặc định là `False`) : Giữ bộ dữ liệu trong bộ nhớ thay vì ghi nó vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ kết quả tính toán hiện tại của `function`, hãy sử dụng tệp đó thay vì tính toán lại. cache_file_names (`[Dict[str, str]]`, *tùy chọn*, mặc định là `None`) : Cung cấp tên của một đường dẫn cho tệp cache. Nó được dùng để lưu trữ kết quả của phép tính thay vì tên tệp cache được tạo tự động. Bạn phải cung cấp một `cache_file_name` cho mỗi dataset trong từ điển dataset. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. fn_kwargs (`Dict`, *tùy chọn*, mặc định là `None`) : Các đối số từ khóa để truyền cho `function` num_proc (`int`, *tuỳ chọn*, mặc định là `None`) : Số lượng tiến trình cần sử dụng cho đa tiến trình. - Nếu là `None` hoặc `0`, sẽ không sử dụng đa tiến trình và thao tác được thực thi trong tiến trình chính. - Nếu lớn hơn `1`, một hoặc nhiều tiến trình worker sẽ được sử dụng để xử lý dữ liệu song song. Lưu ý: Hàm được truyền vào `map()` phải có thể picklable để đa tiến trình hoạt động chính xác (tức là nên ưu tiên các hàm được định nghĩa ở cấp độ trên cùng của một module, thay vì bên trong một hàm hoặc lớp khác). desc (`str`, *tùy chọn*, mặc định là `None`) : Mô tả có ý nghĩa để hiển thị cùng với thanh tiến trình trong khi lọc các ví dụ. Áp dụng một hàm lọc lên tất cả các phần tử trong bảng theo từng lô và cập nhật bảng để tập dữ liệu chỉ bao gồm các ví dụ theo hàm lọc. Phép biến đổi được áp dụng lên tất cả các tập dữ liệu của từ điển tập dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.filter(lambda x: x["label"] == 1) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 4265 }) validation: Dataset({ features: ['text', 'label'], num_rows: 533 }) test: Dataset({ features: ['text', 'label'], num_rows: 533 }) }) ``` #### sort[[datasets.DatasetDict.sort]] ```python sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1151) **Tham số:** column_names (`Union[str, Sequence[str]]`) : Tên cột để sắp xếp. reverse (`Union[bool, Sequence[bool]]`, mặc định là `False`) : Nếu `True`, sắp xếp theo thứ tự giảm dần thay vì tăng dần. Nếu chỉ cung cấp một giá trị bool, giá trị đó sẽ được áp dụng cho việc sắp xếp của tất cả tên cột. Ngược lại, phải cung cấp một danh sách các giá trị bool có cùng độ dài và thứ tự với column_names. null_placement (`str`, mặc định là `at_end`) : Đặt các giá trị `None` ở đầu nếu là `at_start` hoặc `first`, hoặc ở cuối nếu là `at_end` hoặc `last` keep_in_memory (`bool`, mặc định là `False`) : Giữ các chỉ số đã sắp xếp trong bộ nhớ thay vì ghi chúng vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ các chỉ số đã sắp xếp, hãy sử dụng tệp đó thay vì tính toán lại. indices_cache_file_names (`[Dict[str, str]]`, *tùy chọn*, mặc định là `None`) : Cung cấp tên của một đường dẫn cho tệp cache. Nó được dùng để lưu trữ các chỉ số ánh xạ thay vì tên tệp cache được tạo tự động. Bạn phải cung cấp một `cache_file_name` cho mỗi dataset trong từ điển dataset. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị cao hơn tạo ra các tệp cache nhỏ hơn, giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn. Tạo một tập dữ liệu mới được sắp xếp theo một hoặc nhiều cột. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes') >>> ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['train']['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ``` #### shuffle[[datasets.DatasetDict.shuffle]] ```python shuffle(seeds: typing.Union[int, dict[str, typing.Optional[int]], NoneType] = None, seed: typing.Optional[int] = None, generators: typing.Optional[dict[str, numpy.random._generator.Generator]] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1218) **Tham số:** seeds (`Dict[str, int]` hoặc `int`, *không bắt buộc*) : Một seed để khởi tạo BitGenerator mặc định nếu `generator=None`. Nếu là `None`, entropy mới, không thể đoán trước sẽ được lấy từ hệ điều hành. Nếu một `int` hoặc `array_like[ints]` được truyền vào, nó sẽ được truyền đến SeedSequence để suy ra trạng thái BitGenerator ban đầu. Bạn có thể cung cấp một `seed` cho mỗi dataset trong từ điển dataset. seed (`int`, *optional*) : Một seed để khởi tạo BitGenerator mặc định nếu `generator=None`. Là alias cho seeds (một `ValueError` sẽ được ném ra nếu cả hai đều được cung cấp). generators (`Dict[str, *optional*, np.random.Generator]`) : Numpy random Generator để tính toán hoán vị các dòng của dataset. Nếu `generator=None` (mặc định), sẽ sử dụng `np.random.default_rng` (BitGenerator mặc định (PCG64) của NumPy). Bạn phải cung cấp một `generator` cho mỗi dataset trong từ điển dataset. keep_in_memory (`bool`, mặc định là `False`) : Giữ bộ dữ liệu trong bộ nhớ thay vì ghi nó vào tệp cache. load_from_cache_file (`Optional[bool]`, mặc định là `True` nếu caching được bật) : Nếu có thể xác định một tệp cache lưu trữ kết quả tính toán hiện tại của `function`, hãy sử dụng tệp đó thay vì tính toán lại. indices_cache_file_names (`Dict[str, str]`, *tùy chọn*) : Cung cấp tên của đường dẫn cho tệp cache. Nó được dùng để lưu các ánh xạ chỉ số thay vì tên tệp cache được tạo tự động. Bạn phải cung cấp một `cache_file_name` cho mỗi dataset trong từ điển dataset. writer_batch_size (`int`, mặc định là `1000`) : Số dòng cho mỗi thao tác ghi của trình ghi tệp cache. Giá trị này là sự cân bằng tốt giữa mức sử dụng bộ nhớ trong quá trình xử lý và tốc độ xử lý. Giá trị cao hơn giúp quá trình xử lý thực hiện ít lần tra cứu hơn, trong khi giá trị thấp hơn tiêu thụ ít bộ nhớ tạm hơn khi chạy `map`. Tạo một Dataset mới trong đó các hàng được xáo trộn. Biến đổi được áp dụng cho tất cả các tập dữ liệu trong từ điển tập dữ liệu. Hiện tại, shuffling sử dụng các bộ tạo ngẫu nhiên của numpy. Bạn có thể cung cấp một NumPy BitGenerator để sử dụng, hoặc một seed để khởi tạo bộ tạo ngẫu nhiên mặc định của NumPy (PCG64). Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"]["label"][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds["train"]["label"][:10] [0, 1, 0, 1, 0, 0, 0, 0, 0, 0] ``` #### set_format[[datasets.DatasetDict.set_format]] ```python set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L571) **Tham số:** type (`str`, *tùy chọn*) : Kiểu đầu ra được chọn trong `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` có nghĩa là `__getitem__` trả về các đối tượng python (mặc định). columns (`list[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. `None` có nghĩa là `__getitem__` trả về tất cả các cột (mặc định). output_all_columns (`bool`, mặc định là False) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python), - ****format_kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền cho hàm chuyển đổi như `np.array`, `torch.tensor` hoặc `tensorflow.ragged.constant`. Định dạng trả về của `__getitem__` (kiểu và các cột). Định dạng này được thiết lập cho mọi tập dữ liệu trong từ điển tập dữ liệu. Bạn có thể gọi `map` sau khi gọi `set_format`. Vì `map` có thể thêm các cột mới, nên danh sách các cột đã định dạng sẽ được cập nhật. Trong trường hợp này, nếu bạn áp dụng `map` lên một dataset để thêm một cột mới, thì cột này sẽ được định dạng: `new formatted columns = (all columns - previously unformatted columns)` Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} ``` #### reset_format[[datasets.DatasetDict.reset_format]] ```python reset_format() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L622) Đặt lại định dạng trả về của `__getitem__` thành các đối tượng python và tất cả các cột. Phép biến đổi được áp dụng cho tất cả các dataset trong từ điển dataset. Tương tự như `self.set_format()` Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} ``` #### formatted_as[[datasets.DatasetDict.formatted_as]] ```python formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L531) **Tham số:** type (`str`, *tùy chọn*) : Kiểu đầu ra được chọn trong `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` có nghĩa là `__getitem__` trả về các đối tượng python (mặc định). columns (`list[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. `None` có nghĩa là `__getitem__` trả về tất cả các cột (mặc định). output_all_columns (`bool`, mặc định là False) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). - ****format_kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền cho hàm chuyển đổi như `np.array`, `torch.tensor` hoặc `tensorflow.ragged.constant`. Để được sử dụng trong một câu lệnh `with`. Đặt định dạng trả về của `__getitem__` (kiểu và các cột). Phép biến đổi được áp dụng cho tất cả các tập dữ liệu trong từ điển tập dữ liệu. #### with_format[[datasets.DatasetDict.with_format]] ```python with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L683) **Tham số:** type (`str`, *tùy chọn*) : Kiểu đầu ra được chọn trong `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` có nghĩa là `__getitem__` trả về các đối tượng python (mặc định). columns (`list[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. `None` có nghĩa là `__getitem__` trả về tất cả các cột (mặc định). output_all_columns (`bool`, mặc định là `False`) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). - ****format_kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền cho hàm chuyển đổi như `np.array`, `torch.tensor` hoặc `tensorflow.ragged.constant`. Định dạng trả về của `__getitem__` (kiểu và các cột). Việc định dạng dữ liệu được áp dụng theo thời gian thực. Định dạng `type` (ví dụ "numpy") được dùng để định dạng các lô dữ liệu khi sử dụng `__getitem__`. Định dạng này được thiết lập cho từng bộ dữ liệu trong từ điển bộ dữ liệu. Bạn cũng có thể sử dụng các transform tùy chỉnh để định dạng bằng [with_transform()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.with_transform). Ngược lại với [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict.set_format), `with_format` trả về một đối tượng [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) mới với các đối tượng [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) mới. Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format("torch") >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'torch'} >>> ds["train"][0] {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### with_transform[[datasets.DatasetDict.with_transform]] ```python with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L760) **Tham số:** transform (`Callable`, *tùy chọn*) : Biến đổi định dạng do người dùng định nghĩa, thay thế định dạng được định nghĩa bởi [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format). Một hàm định dạng là một callable nhận một batch (dưới dạng dict) làm đầu vào và trả về một batch. Hàm này được áp dụng ngay trước khi trả về các đối tượng trong `__getitem__`. columns (`list[str]`, *tùy chọn*) : Các cột cần định dạng trong đầu ra. Nếu được chỉ định, thì lô đầu vào của transform chỉ chứa các cột đó. output_all_columns (`bool`, mặc định là False) : Giữ lại các cột chưa được định dạng trong đầu ra (dưới dạng đối tượng python). Nếu đặt thành `True`, các cột chưa được định dạng khác sẽ được giữ lại cùng với kết quả của phép biến đổi. Định dạng trả về của `__getitem__` bằng cách sử dụng transform này. Transform được áp dụng trực tiếp trên các batch khi `__getitem__` được gọi. Transform được thiết lập cho mọi dataset trong từ điển dataset Giống như [set_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.set_format), điều này có thể được đặt lại bằng [reset_format()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.reset_format). Ngược lại với `set_transform()`, `with_transform` trả về một đối tượng [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) mới với các đối tượng [Dataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset) mới. Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example['text'], truncation=True, padding=True, return_tensors="pt") >>> ds = ds.with_transform(encode) >>> ds["train"][0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 1103, 2067, 1110, 17348, 1106, 1129, 1103, 6880, 1432, 112, 188, 1207, 107, 14255, 1389, 107, 1105, 1115, 1119, 112, 188, 1280, 1106, 1294, 170, 24194, 1256, 3407, 1190, 170, 11791, 5253, 188, 1732, 7200, 10947, 12606, 2895, 117, 179, 7766, 118, 172, 15554, 1181, 3498, 6961, 3263, 1137, 188, 1566, 7912, 14516, 6997, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### flatten[[datasets.DatasetDict.flatten]] ```python flatten(max_depth = 16) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L193) Phẳng hóa Bảng Apache Arrow của mỗi split (các đặc trưng lồng nhau sẽ được phẳng hóa). Mỗi cột có kiểu struct sẽ được phẳng hóa thành một cột cho mỗi trường struct. Các cột khác được giữ nguyên. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad") >>> ds["train"].features {'id': Value('string'), 'title': Value('string'), 'context': Value('string'), 'question': Value('string'), 'answers.text': List(Value('string')), 'answers.answer_start': List(Value('int32'))} >>> ds.flatten() DatasetDict({ train: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) validation: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 10570 }) }) ``` #### cast[[datasets.DatasetDict.cast]] ```python cast(features: Features) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L274) **Tham số:** features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features)) : Các tính năng mới để chuyển đổi (cast) bộ dữ liệu sang. Tên và thứ tự của các trường trong features phải khớp với tên cột hiện tại. Kiểu dữ liệu cũng phải có thể chuyển đổi từ kiểu này sang kiểu khác. Đối với các phép chuyển đổi không đơn giản, ví dụ `string` <-> `ClassLabel`, bạn nên sử dụng [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict.map) để cập nhật bộ dữ liệu. Đổ dataset sang một tập các đặc trưng mới. Phép biến đổi được áp dụng cho tất cả các dataset trong từ điển dataset. Ví dụ: ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.DatasetDict.cast_column]] ```python cast_column(column: str, feature) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L306) **Tham số:** column (`str`) : Tên cột. feature (`Feature`) : Đặc trưng đích. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Đổ cột sang tính năng để giải mã. Ví dụ: ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.DatasetDict.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L335) **Tham số:** column_names (`Union[str, list[str]]`) : Tên của cột (các cột) cần xóa. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Một bản sao của đối tượng bộ dữ liệu không bao gồm các cột cần xóa. Xóa một hoặc nhiều cột khỏi mỗi split trong dataset cùng với các features liên quan đến các cột đó. Biến đổi được áp dụng cho tất cả các phần chia của từ điển bộ dữ liệu. Bạn cũng có thể xóa một cột bằng cách sử dụng [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict.map) với `remove_columns` nhưng phương pháp hiện tại không sao chép dữ liệu của các cột còn lại nên nhanh hơn. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds = ds.remove_columns("label") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) }) ``` #### rename_column[[datasets.DatasetDict.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L377) **Tham số:** original_column_name (`str`) : Tên của cột cần đổi tên. new_column_name (`str`) : Tên mới cho cột. Đổi tên một cột trong bộ dữ liệu và di chuyển các đặc trưng liên quan đến cột gốc sang dưới tên cột mới. Phép biến đổi được áp dụng cho tất cả các bộ dữ liệu trong từ điển bộ dữ liệu. Bạn cũng có thể đổi tên một cột bằng cách sử dụng [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict.map) với `remove_columns` nhưng phương pháp hiện tại: - loại bỏ các tính năng gốc dưới tên cột mới. - không sao chép dữ liệu sang một tập dữ liệu mới và do đó nhanh hơn nhiều. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds = ds.rename_column("label", "label_new") DatasetDict({ train: Dataset({ features: ['text', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) }) ``` #### rename_columns[[datasets.DatasetDict.rename_columns]] ```python rename_columns(column_mapping: dict) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L425) **Tham số:** column_mapping (`Dict[str, str]`) : Bản ánh xạ từ các cột cần đổi tên sang tên mới của chúng. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Một bản sao của bộ dữ liệu với các cột đã được đổi tên. Đổi tên một số cột trong bộ dữ liệu và di chuyển các đặc trưng liên quan đến các cột gốc sang dưới tên cột mới. Phép biến đổi được áp dụng cho tất cả các bộ dữ liệu trong từ điển bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) DatasetDict({ train: Dataset({ features: ['text_new', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) }) ``` #### select_columns[[datasets.DatasetDict.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L463) **Tham số:** column_names (`Union[str, list[str]]`) : Tên của cột (các cột) cần giữ lại. Chọn một hoặc nhiều cột từ mỗi phần chia trong bộ dữ liệu và các đặc trưng liên quan đến các cột đó. Biến đổi được áp dụng cho tất cả các phần chia của từ điển bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.select_columns("text") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) }) ``` #### class_encode_column[[datasets.DatasetDict.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L499) **Tham số:** column (`str`) : Tên của cột cần chuyển đổi kiểu. include_nulls (`bool`, mặc định là `False`) : Có bao gồm các giá trị null trong nhãn lớp hay không. Nếu `True`, các giá trị null sẽ được mã hóa thành nhãn lớp `"None"`. Đổ cột đã cho sang [ClassLabel](/docs/datasets/main/vi/package_reference/main_classes#datasets.ClassLabel) và cập nhật các bảng. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("google/boolq") >>> ds["train"].features {'answer': Value('bool'), 'passage': Value('string'), 'question': Value('string')} >>> ds = ds.class_encode_column("answer") >>> ds["train"].features {'answer': ClassLabel(num_classes=2, names=['False', 'True']), 'passage': Value('string'), 'question': Value('string')} ``` #### push_to_hub[[datasets.DatasetDict.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1623) **Tham số:** repo_id (`str`) : ID của kho cần đẩy lên, theo định dạng: `/` hoặc `/`. Cũng chấp nhận ``, khi đó sẽ mặc định dùng namespace của người dùng đang đăng nhập. Cũng có thể là một vị trí bên trong bucket, ví dụ `buckets///...` config_name (`str`) : Tên cấu hình của một tập dữ liệu. Mặc định là "default". set_default (`bool`, *tùy chọn*) : Có nên đặt cấu hình này làm cấu hình mặc định hay không. Nếu không, cấu hình mặc định sẽ là cấu hình có tên "default". data_dir (`str`, *tùy chọn*) : Tên thư mục sẽ chứa các tệp dữ liệu đã tải lên. Mặc định là `config_name` nếu khác "default", nếu không thì là "data". commit_message (`str`, *tùy chọn*) : Thông điệp để commit khi đẩy. Mặc định là `"Upload dataset"`. commit_description (`str`, *tùy chọn*) : Mô tả của commit sẽ được tạo. Ngoài ra, mô tả của PR nếu một PR được tạo (`create_pr` là True). private (`bool`, *tuỳ chọn*) : Có nên đặt kho thành riêng tư hay không. Nếu là `None` (mặc định), kho sẽ là công khai trừ khi mặc định của tổ chức là riêng tư. Giá trị này bị bỏ qua nếu kho đã tồn tại. token (`str`, *tùy chọn*) : Một token xác thực tùy chọn cho Hugging Face Hub. Nếu không truyền token, hệ thống sẽ mặc định sử dụng token được lưu cục bộ khi đăng nhập bằng `hf auth login`. Sẽ gây ra lỗi nếu không truyền token và người dùng chưa đăng nhập. revision (`str`, *tùy chọn*) : Nhánh để đẩy các tệp đã tải lên. Mặc định là nhánh `"main"`. create_pr (`bool`, *tùy chọn*, mặc định là `False`) : Có tạo PR với các tệp đã tải lên hay commit trực tiếp hay không. max_shard_size (`int` hoặc `str`, *tuỳ chọn*, mặc định là `"500MB"`) : Kích thước tối đa của các shard dữ liệu sẽ được tải lên hub. Nếu được biểu diễn dưới dạng chuỗi, cần phải là các chữ số theo sau bởi một đơn vị (như `"500MB"` hoặc `"1GB"`). num_shards (`Dict[str, int]`, *tùy chọn*) : Số lượng shard cần ghi. Mặc định, số lượng shard phụ thuộc vào `max_shard_size`. Sử dụng từ điển để định nghĩa num_shards khác nhau cho từng split. embed_external_files (`bool`, mặc định là `True`) : Xác định có nhúng byte của tệp vào các shard hay không. Cụ thể, trước khi đẩy lên, thao tác này sẽ thực hiện các bước sau cho các trường có kiểu: - [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) và [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image) sẽ xóa thông tin đường dẫn cục bộ và nhúng nội dung tệp vào các tệp Parquet. num_proc (`int`, *optional*, mặc định là `None`) : Số lượng tiến trình khi chuẩn bị và tải lên bộ dữ liệu. Điều này hữu ích nếu bộ dữ liệu gồm nhiều mẫu hoặc tệp phương tiện cần nhúng. I sử dụng ngữ cảnh "spawn" để hoạt động với hf_xet, client rust cho việc tải lên HF nhanh chóng. Đa tiến trình bị vô hiệu hóa theo mặc định. **Trả về:** huggingface_hub.CommitInfo Đẩy [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) lên hub dưới dạng tập dữ liệu Parquet. [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) được đẩy bằng các yêu cầu HTTP và không cần cài đặt git hoặc git-lfs. Mỗi phần chia của bộ dữ liệu sẽ được đẩy lên độc lập. Bộ dữ liệu được đẩy lên sẽ giữ nguyên tên các phần chia ban đầu. Các tệp Parquet kết quả mặc định là tự chứa: nếu tập dữ liệu của bạn chứa dữ liệu [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image) hoặc [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio), các tệp Parquet sẽ lưu trữ các byte của hình ảnh hoặc tệp âm thanh của bạn. Bạn có thể tắt điều này bằng cách đặt `embed_external_files` thành False. Ví dụ: ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Nếu bạn muốn thêm một cấu hình (hoặc tập con) mới vào một tập dữ liệu (ví dụ: nếu tập dữ liệu có nhiều tác bản/phân bản/ngôn ngữ): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### save_to_disk[[datasets.DatasetDict.save_to_disk]] ```python save_to_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1301) **Tham số:** dataset_dict_path (`path-like`) : Path (ví dụ `dataset/train`) hoặc URI từ xa (ví dụ `s3://my-bucket/dataset/train`) của thư mục dict dataset, nơi dict dataset sẽ được lưu. max_shard_size (`int` hoặc `str`, *không bắt buộc*, mặc định là `"500MB"`) : Kích thước tối đa của các shard dữ liệu sẽ được lưu vào hệ thống tệp. Nếu được biểu diễn dưới dạng chuỗi, cần phải là các chữ số theo sau bởi một đơn vị (ví dụ `"50MB"`). num_shards (`Dict[str, int]`, *tùy chọn*) : Số lượng shard cần ghi. Mặc định, số lượng shard phụ thuộc vào `max_shard_size` và `num_proc`. Bạn cần cung cấp số lượng shard cho từng dataset trong từ điển dataset. Sử dụng từ điển để định nghĩa num_shards khác nhau cho mỗi split. num_proc (`int`, *tuỳ chọn*, mặc định `None`) : Số lượng tiến trình khi tải xuống và tạo bộ dữ liệu cục bộ. Đa tiến trình bị vô hiệu hóa theo mặc định. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. Lưu một dict dataset vào hệ thống tệp bằng `fsspec.spec.AbstractFileSystem`. Đối với dữ liệu [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) và [Video](/docs/datasets/main/vi/package_reference/main_classes#datasets.Video): Tất cả dữ liệu Image(), Audio() và Video() được lưu trữ trong các tệp arrow. Nếu bạn muốn lưu trữ đường dẫn hoặc url, vui lòng sử dụng kiểu Value("string"). Ví dụ: ```python >>> dataset_dict.save_to_disk("path/to/dataset/directory") >>> dataset_dict.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> dataset_dict.save_to_disk("path/to/dataset/directory", num_shards={"train": 1024, "test": 8}) ``` #### load_from_disk[[datasets.DatasetDict.load_from_disk]] ```python load_from_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1375) **Tham số:** dataset_dict_path (`path-like`) : Path (ví dụ `"dataset/train"`) hoặc URI từ xa (ví dụ `"s3//my-bucket/dataset/train"`) của thư mục dataset dict, nơi dataset dict sẽ được tải từ đó. keep_in_memory (`bool`, mặc định là `None`) : Có sao chép bộ dữ liệu trong bộ nhớ hay không. Nếu là `None`, bộ dữ liệu sẽ không được sao chép trong bộ nhớ trừ khi được bật rõ ràng bằng cách đặt `datasets.config.IN_MEMORY_MAX_SIZE` thành giá trị khác không. Xem thêm chi tiết trong phần [cải thiện hiệu suất](../cache#improve-performance). storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Tải một tập dữ liệu đã được lưu trước đó bằng `save_to_disk` từ hệ thống tệp bằng `fsspec.spec.AbstractFileSystem`. Ví dụ: ```py >>> ds = load_from_disk('path/to/dataset/directory') ``` #### from_csv[[datasets.DatasetDict.from_csv]] ```python from_csv(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1435) **Tham số:** path_or_paths (`dict` của path-like) : Đường dẫn của tệp CSV. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (str, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `pandas.read_csv`. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Tạo [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) từ tệp CSV. Ví dụ: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_csv({'train': 'path/to/dataset.csv'}) ``` #### from_json[[datasets.DatasetDict.from_json]] ```python from_json(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1478) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp JSON Lines. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (str, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `JsonConfig`. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Tạo [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) từ tệp JSON Lines. Ví dụ: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_json({'train': 'path/to/dataset.json'}) ``` #### from_parquet[[datasets.DatasetDict.from_parquet]] ```python from_parquet(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1521) **Tham số:** path_or_paths (`dict` của path-like) : Đường dẫn của tệp CSV. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. columns (`list[str]`, *tùy chọn*) : Nếu không phải `None`, chỉ các cột này sẽ được đọc từ tệp. Tên cột có thể là tiền tố của một trường lồng nhau, ví dụ 'a' sẽ chọn 'a.b', 'a.c' và 'a.d.e'. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `ParquetConfig`. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Tạo [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) từ tệp Parquet. Ví dụ: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_parquet({'train': 'path/to/dataset/parquet'}) ``` #### from_text[[datasets.DatasetDict.from_text]] ```python from_text(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1570) **Tham số:** path_or_paths (`dict` của path-like) : Đường dẫn của tệp văn bản. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. cache_dir (`str`, *tùy chọn*, mặc định là `"~/.cache/huggingface/datasets"`) : Thư mục để lưu bộ nhớ đệm dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `TextConfig`. **Trả về:** [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) Tạo [DatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetDict) từ tệp văn bản. Ví dụ: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_text({'train': 'path/to/dataset.txt'}) ``` ## IterableDataset[[datasets.IterableDataset]] Lớp cơ sở [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) triển khai một Dataset có thể lặp lại, được hỗ trợ bởi các trình tạo python. #### datasets.IterableDataset[[datasets.IterableDataset]] ```python datasets.IterableDataset(ex_iterable: _BaseExamplesIterable, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, formatting: typing.Optional[datasets.iterable_dataset.FormattingConfig] = None, distributed: typing.Optional[datasets.iterable_dataset.DistributedConfig] = None, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2690) Một Dataset được hỗ trợ bởi một iterable. #### from_file[[datasets.IterableDataset.from_file]] ```python from_file(filename: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3188) **Tham số:** filename (`str`) : Tên tệp của bộ dữ liệu. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Tạo một IterableDataset từ bảng Arrow tại tệp có tên filename. #### from_pandas[[datasets.IterableDataset.from_pandas]] ```python from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None, num_shards: typing.Optional[int] = 1) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3204) **Tham số:** df (`pandas.DataFrame`) : Dataframe chứa bộ dữ liệu. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. info (`DatasetInfo`, *tùy chọn*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, *tùy chọn*) : Tên của phần chia bộ dữ liệu. preserve_index (`bool`, *tuỳ chọn*) : Có lưu trữ chỉ số dưới dạng một cột bổ sung trong Dataset kết quả hay không. Giá trị mặc định `None` sẽ lưu trữ chỉ số dưới dạng một cột, ngoại trừ `RangeIndex` chỉ được lưu trữ dưới dạng metadata. Sử dụng `preserve_index=True` để buộc lưu trữ dưới dạng một cột. num_shards (`int`, mặc định là `1`) : Số lượng shard cần định nghĩa khi khởi tạo bộ dữ liệu dạng iterable. Điều này đặc biệt hữu ích cho các bộ dữ liệu lớn để có thể xáo trộn (shuffle) đúng cách, đồng thời cho phép tải song song nhanh chóng bằng PyTorch DataLoader hoặc trong các cấu hình phân tán, chẳng hạn. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Chuyển đổi `pandas.DataFrame` thành `pyarrow.Table` để tạo một [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset). Các kiểu cột trong Arrow Table kết quả được suy ra từ dtypes của `pandas.Series` trong DataFrame. Đối với các Series không phải object, NumPy dtype được chuyển đổi sang tương đương Arrow của nó. Đối với `object`, chúng ta cần đoán kiểu dữ liệu bằng cách xem xét các đối tượng Python trong Series này. Lưu ý rằng các Series có dtype `object` không chứa đủ thông tin để luôn dẫn đến một kiểu Arrow có ý nghĩa. Trong trường hợp không thể suy luận được kiểu, ví dụ vì DataFrame có độ dài 0 hoặc Series chỉ chứa các đối tượng `None/nan`, kiểu sẽ được đặt thành `null`. Có thể tránh hành vi này bằng cách xây dựng các feature rõ ràng và truyền chúng vào hàm này. Quan trọng: một dataset được tạo bằng from_pandas() sẽ nằm trong bộ nhớ. Điều này có thể thay đổi trong tương lai, nhưng trong thời gian chờ đợi, nếu bạn muốn giảm mức sử dụng bộ nhớ thì nên ghi nó ra đĩa và tải lại bằng cách sử dụng ví dụ to_parquet / from_parquet. Ví dụ: ```py >>> ds = IterableDataset.from_pandas(df) ``` #### from_dict[[datasets.IterableDataset.from_dict]] ```python from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3316) **Tham số:** mapping (`Mapping`) : Ánh xạ các chuỗi sang các mảng hoặc danh sách Python. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. info (`DatasetInfo`, *tùy chọn*) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, *tùy chọn*) : Tên của phần chia bộ dữ liệu. num_shards (`int`, mặc định là `1`) : Số lượng shard cần định nghĩa khi khởi tạo bộ dữ liệu dạng iterable. Điều này đặc biệt hữu ích cho các bộ dữ liệu lớn để có thể xáo trộn (shuffle) đúng cách, đồng thời cho phép tải song song nhanh chóng bằng PyTorch DataLoader hoặc trong các cấu hình phân tán, chẳng hạn. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Chuyển đổi `dict` thành `pyarrow.Table` để tạo một [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset). Quan trọng: một dataset được tạo bằng from_dict() sẽ nằm trong bộ nhớ. Điều này có thể thay đổi trong tương lai, nhưng trong thời gian chờ đợi, nếu bạn muốn giảm mức sử dụng bộ nhớ, bạn nên ghi lại nó xuống đĩa và tải lại bằng cách sử dụng ví dụ to_parquet / from_parquet. #### from_list[[datasets.IterableDataset.from_list]] ```python from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3353) **Tham số:** mapping (`List[dict]`) : Một danh sách các ánh xạ từ chuỗi đến giá trị hàng. features (`Features`, tùy chọn) : Các đặc trưng của tập dữ liệu. info (`DatasetInfo`, tùy chọn) : Thông tin về bộ dữ liệu, chẳng hạn như mô tả, trích dẫn, v.v. split (`NamedSplit`, tùy chọn) : Tên của phần chia bộ dữ liệu. num_shards (`int`, mặc định là `1`) : Số lượng shard cần định nghĩa khi khởi tạo bộ dữ liệu dạng iterable. Điều này đặc biệt hữu ích cho các bộ dữ liệu lớn để có thể xáo trộn (shuffle) đúng cách, đồng thời cho phép tải song song nhanh chóng bằng PyTorch DataLoader hoặc trong các cấu hình phân tán, chẳng hạn. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Chuyển đổi một danh sách các dict thành một `pyarrow.Table` để tạo một [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset)` Lưu ý rằng các khóa của mục đầu tiên sẽ được sử dụng để xác định các cột của bộ dữ liệu, bất kể giá trị nào được truyền vào features. Quan trọng: một dataset được tạo bằng from_list() sẽ nằm trong bộ nhớ. Điều này có thể thay đổi trong tương lai, nhưng trong thời gian chờ đợi, nếu bạn muốn giảm mức sử dụng bộ nhớ thì nên ghi lại xuống đĩa và tải lại bằng cách sử dụng ví dụ from_parquet / to_parquet. #### from_generator[[datasets.IterableDataset.from_generator]] ```python from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, gen_kwargs: typing.Optional[dict] = None, split: NamedSplit = NamedSplit('train')) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3090) **Tham số:** generator (`Callable`) : Một hàm generator mà `yields` các ví dụ. features (`Features`, *tùy chọn*) : Các đặc trưng của tập dữ liệu. gen_kwargs(`dict`, *tuỳ chọn*) : Các đối số theo từ khóa để truyền cho callable `generator`. Bạn có thể định nghĩa một tập dữ liệu lặp lại phân mảnh bằng cách truyền danh sách các phân mảnh trong `gen_kwargs`. Điều này có thể được sử dụng để cải thiện việc xáo trộn và khi lặp qua tập dữ liệu với nhiều worker. split ([NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit), mặc định là `Split.TRAIN`) : Tên split được gán cho tập dữ liệu. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Tạo một Iterable Dataset từ một generator. Ví dụ: ```py >>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = IterableDataset.from_generator(gen) ``` ```py >>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = IterableDataset.from_generator(gen, gen_kwargs={"shards": shards}) >>> ds = ds.shuffle(seed=42, buffer_size=10_000) # shuffles the shards order + uses a shuffle buffer >>> from torch.utils.data import DataLoader >>> dataloader = DataLoader(ds.with_format("torch"), num_workers=4) # give each worker a subset of 32/4=8 shards ``` #### remove_columns[[datasets.IterableDataset.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4343) **Tham số:** column_names (`Union[str, List[str]]`) : Tên của cột (các cột) cần xóa. **Trả về:** `IterableDataset` Một bản sao của đối tượng bộ dữ liệu không bao gồm các cột cần xóa. Xóa một hoặc nhiều cột trong bộ dữ liệu cùng với các đặc trưng liên quan đến chúng. Việc xóa được thực hiện trực tiếp trên các ví dụ khi lặp qua bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.remove_columns("label") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### select_columns[[datasets.IterableDataset.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4378) **Tham số:** column_names (`Union[str, List[str]]`) : Tên của cột (các cột) cần chọn. **Trả về:** `IterableDataset` Bản sao của đối tượng bộ dữ liệu với các cột được chọn. Chọn một hoặc nhiều cột trong bộ dữ liệu cùng các đặc trưng liên quan đến chúng. Việc chọn lọc được thực hiện trực tiếp trên các ví dụ khi lặp qua bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.select_columns("text") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### cast_column[[datasets.IterableDataset.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4428) **Tham số:** column (`str`) : Tên cột. feature (`Feature`) : Đặc trưng đích. **Trả về:** `IterableDataset` Đổ cột sang tính năng để giải mã. Ví dụ: ```py >>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train", streaming=True) >>> ds.features {'audio': Audio(sampling_rate=8000, mono=True, decode=True, id=None), 'english_transcription': Value('string'), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']), 'path': Value('string'), 'transcription': Value('string')} >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000)) >>> ds.features {'audio': Audio(sampling_rate=16000, mono=True, decode=True, id=None), 'english_transcription': Value('string'), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']), 'path': Value('string'), 'transcription': Value('string')} ``` #### cast[[datasets.IterableDataset.cast]] ```python cast(features: Features) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4474) **Tham số:** features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features)) : Các tính năng mới để chuyển đổi (cast) dataset sang. Tên của các trường trong features phải khớp với tên cột hiện tại. Kiểu dữ liệu cũng phải có thể chuyển đổi từ kiểu này sang kiểu khác. Đối với các phép chuyển đổi không đơn giản, ví dụ `string` <-> `ClassLabel`, bạn nên sử dụng [map()](/docs/datasets/main/vi/package_reference/main_classes#datasets.Dataset.map) để cập nhật Dataset. **Trả về:** `IterableDataset` Một bản sao của bộ dữ liệu với các đặc trưng đã được chuyển đổi kiểu. Đổ khuôn (cast) bộ dữ liệu sang một tập tính năng mới. Ví dụ: ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds.features.copy() >>> new_features["label"] = ClassLabel(names=["bad", "good"]) >>> new_features["text"] = Value("large_string") >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### decode[[datasets.IterableDataset.decode]] ```python decode(enable: bool = True, num_threads: typing.Optional[int] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4520) **Tham số:** enable (`bool`, mặc định là `True`) : Bật hoặc tắt tính năng giải mã. num_threads (`int`, *tuỳ chọn*, mặc định là `None`) : Bật đa luồng cho việc giải mã các đặc trưng. Lưu ý rằng [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset) đã sử dụng một vài luồng theo mặc định khi stream một dataset trên HF với các đặc trưng có thể giải mã được. Theo mặc định, `num_threads` được đặt thành 32 nếu ít nhất một đặc trưng yêu cầu giải mã, và 0 trong trường hợp ngược lại. **Trả về:** `IterableDataset` Một bản sao của bộ dữ liệu với các đặc trưng đã được chuyển đổi kiểu. Bật hoặc tắt việc giải mã các tính năng của bộ dữ liệu cho âm thanh, hình ảnh, video. Khi được bật (mặc định), các loại phương tiện sẽ được giải mã: * audio -> dict của "array" và "sampling_rate" và "path" * image -> PIL.Image * video -> torchcodec.decoders.VideoDecoder Multithreading có thể được bật bằng `num_threads`: khi đó, mỗi tệp media sẽ được đọc và giải mã trong một worker thread, giúp các lượt đi về mạng của các ví dụ liên tiếp được chồng lên nhau. Điều này đặc biệt hữu ích để tăng tốc việc stream dữ liệu từ xa, và [load_dataset()](/docs/datasets/main/vi/package_reference/loading_methods#datasets.load_dataset) đã bật tính năng này theo mặc định khi stream một dataset từ xa có các đặc trưng có thể giải mã (xem `HF_DATASETS_DECODE_NUM_THREADS`). Các dataset được đọc từ ổ đĩa cục bộ sẽ được stream với `num_threads=0`, vì multithreading có thể chậm hơn so với việc giải mã trong main thread đối với dữ liệu cục bộ trên các ổ đĩa nhanh. Vì các ví dụ được giải mã trước, mỗi thread đang chạy có thể giữ một ví dụ trong bộ nhớ: hãy giảm `num_threads` để sử dụng ít bộ nhớ hơn. Việc tắt giải mã hữu ích nếu bạn muốn lặp lại trên các đường dẫn hoặc byte của các tệp phương tiện mà không thực sự giải mã nội dung của chúng. Để tắt giải mã, bạn có thể sử dụng `.decode(False)`, tương đương với việc gọi `.cast()` hoặc `.cast_column()` với tất cả các kiểu Audio, Image và Video được đặt thành `decode=False`. Ví dụ: Tắt giải mã: ```py >>> from datasets import load_dataset >>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True) >>> next(iter(ds)) {'image': , 'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.'} >>> ds = ds.decode(False) >>> ds.features {'image': Image(mode=None, decode=False, id=None), 'text': Value('string')} >>> next(iter(ds)) { 'image': { 'path': 'hf://datasets/sshh12/planet-textures@69dc4cef7a5c4b2cfe387727ec8ea73d4bff7302/train/textures/0000.png', 'bytes': None }, 'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.' } ``` Tăng tốc độ streaming bằng đa luồng: ```py >>> import os >>> from datasets import load_dataset >>> from tqdm import tqdm >>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True) >>> # already threaded by default with 32 threads, but more threads can help going even faster >>> ds = ds.decode(num_threads=64) >>> for _ in tqdm(ds): # 2 times faster ! ... ... ``` #### __iter__[[datasets.IterableDataset.__iter__]] ```python __iter__() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3035) #### iter[[datasets.IterableDataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3056) **Tham số:** batch_size (`int`) : kích thước của mỗi batch để tạo ra. drop_last_batch (`bool`, mặc định *False*) : Có nên loại bỏ một batch cuối nhỏ hơn batch_size hay không Lặp qua các lô có kích thước *batch_size*. #### map[[datasets.IterableDataset.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, features: typing.Optional[datasets.features.features.Features] = None, fn_kwargs: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3676) **Tham số:** function (`Callable`, *tùy chọn*, mặc định là `None`) : Hàm được áp dụng trực tiếp lên các ví dụ khi bạn lặp qua tập dữ liệu. Nó phải có một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> Dict[str, Any]` nếu `batched=False` và `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` nếu `batched=False` và `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]` nếu `batched=True` và `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]` nếu `batched=True` và `with_indices=True` Đối với cách sử dụng nâng cao, hàm cũng có thể trả về một `pyarrow.Table`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song. Hơn nữa, nếu hàm của bạn không trả về gì (`None`), thì `map` sẽ chạy hàm của bạn và trả về tập dữ liệu không thay đổi. Nếu không cung cấp hàm nào, mặc định là hàm đồng nhất: `lambda x: x`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx[, rank]): ...`. input_columns (`Optional[Union[str, List[str]]]`, mặc định là `None`) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một dict ánh xạ đến tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function`. batch_size (`int`, *tuỳ chọn*, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched=True`. Nếu `batch_size <= 0` hoặc `batch_size == None` thì cung cấp toàn bộ tập dữ liệu như một batch duy nhất cho `function`. drop_last_batch (`bool`, mặc định là `False`) : Xác định xem một batch cuối nhỏ hơn batch_size có nên bị loại bỏ thay vì được xử lý bởi hàm hay không. remove_columns (`[List[str]]`, *tùy chọn*, mặc định là `None`) : Loại bỏ một tập các cột khi thực hiện ánh xạ. Các cột sẽ bị loại bỏ trước khi cập nhật các ví dụ bằng kết quả đầu ra của `function`, tức là nếu `function` thêm các cột có tên nằm trong `remove_columns`, các cột này sẽ được giữ lại. features (`[Features]`, *tùy chọn*, mặc định là `None`) : Các kiểu đặc trưng của bộ dữ liệu kết quả. fn_kwargs (`Dict`, *tùy chọn*, mặc định `None`) : Các đối số theo từ khóa để truyền cho `function`. Áp dụng một hàm lên tất cả các ví dụ trong tập dữ liệu dạng lặp (riêng lẻ hoặc theo lô) và cập nhật chúng. Nếu hàm của bạn trả về một cột đã tồn tại, nó sẽ ghi đè lên cột đó. Hàm được áp dụng trực tiếp lên các ví dụ khi lặp qua tập dữ liệu. Bạn có thể chỉ định xem hàm có nên được xử lý theo lô (batched) hay không bằng tham số `batched`: - Nếu `False`, thì hàm nhận vào 1 ví dụ và phải trả về 1 ví dụ. Một ví dụ là một từ điển, ví dụ `{"text": "Hello there !"}`. - Nếu `True` và `batch_size` là 1, thì hàm nhận vào một batch gồm 1 ví dụ và có thể trả về một batch gồm 1 hoặc nhiều hơn các ví dụ. Một batch là một từ điển, ví dụ một batch gồm 1 ví dụ là {"text": ["Hello there !"]}. - Nếu `True` và `batch_size` là `n` > 1, thì hàm nhận vào một batch gồm `n` ví dụ và có thể trả về một batch gồm `n` ví dụ, hoặc một số lượng ví dụ bất kỳ. Lưu ý rằng batch cuối cùng có thể có ít hơn `n` ví dụ. Một batch là một dictionary, ví dụ một batch gồm `n` ví dụ là `{"text": ["Hello there !"] * n}`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song, với tối đa một nghìn cuộc gọi đồng thời. Khuyến nghị sử dụng `asyncio.Semaphore` trong hàm của bạn nếu bạn muốn đặt số lượng tối đa các thao tác có thể chạy cùng lúc. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> list(ds.take(3)) [{'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'Review: effective but too-tepid biopic'}] ``` #### rename_column[[datasets.IterableDataset.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4288) **Tham số:** original_column_name (`str`) : Tên của cột cần đổi tên. new_column_name (`str`) : Tên mới cho cột. **Trả về:** `IterableDataset` Một bản sao của bộ dữ liệu với một cột đã được đổi tên. Đổi tên một cột trong bộ dữ liệu, và di chuyển các đặc trưng liên quan đến cột gốc sang dưới tên cột mới. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds)) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### lọc[[datasets.IterableDataset.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3858) **Tham số:** function (`Callable`) : Callable có một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> bool` nếu `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` nếu `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]` nếu `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]` nếu `with_indices=True, batched=True` Nếu hàm là bất đồng bộ, thì `filter` sẽ chạy hàm của bạn song song. Nếu không cung cấp hàm, mặc định là hàm luôn trả về True: `lambda x: True`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx): ...`. input_columns (`str` hoặc `List[str]`, *tùy chọn*) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một dict ánh xạ đến tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function`. batch_size (`int`, *tuỳ chọn*, mặc định `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched=True`. fn_kwargs (`Dict`, *tùy chọn*, mặc định `None`) : Các đối số theo từ khóa để truyền cho `function`. Áp dụng một hàm lọc lên tất cả các phần tử để tập dữ liệu chỉ bao gồm các ví dụ theo hàm lọc đó. Việc lọc được thực hiện trực tiếp khi lặp qua tập dữ liệu. Nếu hàm là bất đồng bộ, thì `filter` sẽ chạy hàm của bạn song song, với tối đa một nghìn cuộc gọi đồng thời (có thể cấu hình). Khuyến nghị sử dụng `asyncio.Semaphore` trong hàm của bạn nếu bạn muốn đặt số lượng tối đa các thao tác có thể chạy cùng lúc. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds.take(3)) [{'label': 0, 'movie_review': 'simplistic , silly and tedious .'}, {'label': 0, 'movie_review': "it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'movie_review': 'exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}] ``` #### shuffle[[datasets.IterableDataset.shuffle]] ```python shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3961) **Tham số:** seed (`int`, *tuỳ chọn*, mặc định là `None`) : Hạt ngẫu nhiên sẽ được sử dụng để xáo trộn bộ dữ liệu. Nó được dùng để lấy mẫu từ bộ đệm xáo trộn và cũng để xáo trộn các mảnh dữ liệu. generator (`numpy.random.Generator`, *tùy chọn*) : Numpy random Generator được sử dụng để tính hoán vị các dòng của tập dữ liệu. Nếu `generator=None` (mặc định), sẽ sử dụng `np.random.default_rng` (BitGenerator mặc định (PCG64) của NumPy). buffer_size (`int`, mặc định là `1000`) : Kích thước của bộ đệm. max_buffer_input_shards (`int`, mặc định là `10`) : Số lượng shard tối đa được sử dụng để nạp vào buffer mỗi lần. Trộn ngẫu nhiên các phần tử của tập dữ liệu này. Dataset này điền một buffer với `buffer_size` phần tử, sau đó lấy mẫu ngẫu nhiên các phần tử từ buffer này, thay thế các phần tử được chọn bằng các phần tử mới. Để xáo trộn hoàn hảo, kích thước buffer phải lớn hơn hoặc bằng kích thước đầy đủ của dataset. Ví dụ, nếu tập dữ liệu của bạn chứa 10.000 phần tử nhưng `buffer_size` được đặt là 1000, thì `shuffle` ban đầu sẽ chọn một phần tử ngẫu nhiên chỉ từ 1000 phần tử đầu tiên trong bộ đệm. Khi một phần tử được chọn, vị trí của nó trong bộ đệm sẽ được thay thế bằng phần tử tiếp theo (tức là phần tử thứ 1.001), duy trì bộ đệm 1000 phần tử. Nếu tập dữ liệu được tạo từ nhiều shard, nó sẽ lấp đầy bộ đệm bằng cách sử dụng tối đa `max_buffer_input_shards` shard mỗi lần và cũng xáo trộn thứ tự của các shard. Điều này cải thiện đáng kể chất lượng của việc xáo trộn. Các shard đầu vào được xen kẽ trong mỗi node và worker, giữ nguyên số lượng shard có sẵn cho việc tải dữ liệu song song. Tuy nhiên, nếu thứ tự đã được cố định bằng cách sử dụng [skip()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.skip) hoặc [take()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.take), thì thứ tự của các shard sẽ được giữ nguyên và chỉ một shard tại một thời điểm được sử dụng để lấp đầy bộ đệm. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1}, {'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .', 'label': 1}, {'text': 'effective but too-tepid biopic', 'label': 1}] >>> shuffled_ds = ds.shuffle(seed=42) >>> list(shuffled_ds.take(3)) [{'text': "a sports movie with action that's exciting on the field and a story you care about off it .", 'label': 1}, {'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .', 'label': 1}, {'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune .", 'label': 1}] >>> resharded_ds = ds.reshard() # useful to shard Parquet datasets by row group instead of by file, improving shuffling quality on dataset with one or few files. >>> shuffled_resharded_ds = resharded_ds.shuffle(seed=42) >>> list(shuffled_resharded_ds.take(3)) [{'text': 'this mistaken-identity picture is so film-culture referential that the final product is a ghost .', 'label': 0}, {'text': 'woody allen used to ridicule movies like hollywood ending . now he makes them .', 'label': 0}, {'text': "not only is undercover brother as funny , if not more so , than both austin powers films , but it's also one of the smarter , savvier spoofs to come along in some time .", 'label': 1}] ``` #### batch[[datasets.IterableDataset.batch]] ```python batch(batch_size: typing.Optional[int] = None, by_column: typing.Union[str, list[str], NoneType] = None, drop_last_batch: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4657) **Tham số:** batch_size (`int`, tùy chọn) : Số lượng mẫu trong mỗi lô. by_column (`Union[str, list[str]`, optional) : Cột được sử dụng để nhóm các ví dụ thành từng lô. Các ví dụ liên tiếp có cùng giá trị cho cột đó sẽ được nhóm vào cùng một lô. Đây cũng có thể là một danh sách các cột nếu bạn muốn nhóm theo nhiều cột. Khi nhóm theo cột, batch_size chỉ được dùng để kiểm soát kích thước của các lô cần được nhóm lại hoặc cắt trong quá trình tích lũy. drop_last_batch (`bool`, mặc định là `False`) : Có nên loại bỏ lô cuối cùng không hoàn chỉnh hay không. Nhóm các mẫu từ tập dữ liệu thành các lô (batches). Ví dụ: Kích thước lô cố định: ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(batch_size=32) ``` Các lô mẫu liên tiếp có giá trị giống nhau cho "my_column": ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(by_column="my_column") ``` #### bỏ qua[[datasets.IterableDataset.skip]] ```python skip(n: int) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4058) **Tham số:** n (`int`) : Số phần tử cần bỏ qua. Tạo một [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) mới bỏ qua `n` phần tử đầu tiên. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}] ``` #### take[[datasets.IterableDataset.take]] ```python take(n: int) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4144) **Tham số:** n (`int`) : Số lượng phần tử cần lấy. Tạo một [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) mới chỉ chứa `n` phần tử đầu tiên. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}] ``` #### shard[[datasets.IterableDataset.shard]] ```python shard(num_shards: int, index: int, contiguous: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4179) **Tham số:** num_shards (`int`) : Số lượng shard để chia bộ dữ liệu. index (`int`) : Shard cần chọn và trả về. contiguous : (`bool`, mặc định là `True`): Có nên chọn các khối chỉ số liên tục cho các shard hay không. Trả về shard thứ `index` từ tập dữ liệu được chia thành `num_shards` phần. Thao tác này chia nhỏ (shard) một cách tất định. `dataset.shard(n, i)` chia bộ dữ liệu thành các khối liên tục, do đó có thể dễ dàng nối lại sau khi xử lý. Nếu `dataset.num_shards % n == l`, thì `l` bộ dữ liệu đầu tiên mỗi bộ có `(dataset.num_shards // n) + 1` shard, và các bộ dữ liệu còn lại có `(dataset.num_shards // n)` shard. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` trả về một bộ dữ liệu có cùng thứ tự như ban đầu. Cụ thể, `dataset.shard(dataset.num_shards, i)` trả về một bộ dữ liệu có 1 shard. Lưu ý: n phải nhỏ hơn hoặc bằng số lượng shard trong dataset `dataset.num_shards`. Mặt khác, `dataset.shard(n, i, contiguous=False)` chứa tất cả các shard của tập dữ liệu có chỉ số mod `n = i`. Hãy đảm bảo thực hiện chia shard trước khi sử dụng bất kỳ toán tử ngẫu nhiên hóa nào (chẳng hạn như `shuffle`). Tốt nhất là toán tử shard nên được sử dụng sớm trong pipeline của dataset. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True) >>> ds IterableDataset({ features: ['label', 'title', 'content'], num_shards: 4 }) >>> ds.shard(num_shards=2, index=0) IterableDataset({ features: ['label', 'title', 'content'], num_shards: 2 }) ``` #### reshard[[datasets.IterableDataset.reshard]] ```python reshard() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4235) Tái chia dataset nếu có thể, tức là chia các shard hiện tại thành nhiều shard hơn. Điều này làm tăng số lượng shard và dataset kết quả sẽ có num_shards >= previous_num_shards. Trường hợp bằng nhau có thể xảy ra nếu không shard nào có thể được chia nhỏ hơn nữa. Cơ chế resharding phụ thuộc vào định dạng tệp của tập dữ liệu: * Parquet: chia shard theo từng nhóm hàng thay vì theo từng tệp * Vortex: chia shard theo từng khoảng các chunk liên tiếp (mỗi khoảng chứa khoảng 64MB dữ liệu tệp) thay vì theo từng tệp * Khác: chưa được triển khai (chúng tôi hoan nghênh các đóng góp!) Hãy đảm bảo thực hiện reshard/shard trước khi sử dụng bất kỳ toán tử ngẫu nhiên hóa nào (chẳng hạn như `shuffle`). Tốt nhất là toán tử shard nên được sử dụng sớm trong pipeline của dataset. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True) >>> ds IterableDataset({ features: ['label', 'title', 'content'], num_shards: 4 }) >>> ds.reshard() IterableDataset({ features: ['label', 'title', 'content'], num_shards: 3600 }) ``` #### repeat[[datasets.IterableDataset.repeat]] ```python repeat(num_times: typing.Optional[int]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4100) **Tham số:** num_times (`int`) hoặc (`None`) : Số lần lặp lại bộ dữ liệu. Nếu là `None`, bộ dữ liệu sẽ được lặp lại vô hạn. Tạo một [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) mới lặp lại tập dữ liệu cơ bản `num_times` lần. Đầu vào rỗng sẽ kết thúc ngay cả khi `num_times` là `None`. N.B. Tác động của việc gọi shuffle sau repeat phụ thuộc đáng kể vào kích thước buffer. Với buffer_size 1, dữ liệu trùng lặp không bao giờ xuất hiện trong cùng một lần lặp, ngay cả sau khi xáo trộn: ds.repeat(n).shuffle(seed=42, buffer_size=1) tương đương với ds.shuffle(seed=42, buffer_size=1).repeat(n), và chỉ xáo trộn thứ tự các shard trong mỗi lần lặp. Với kích thước buffer >= (số mẫu trong tập dữ liệu * num_times), chúng ta có được việc xáo trộn hoàn toàn dữ liệu đã lặp, tức là chúng ta có thể quan sát thấy các bản sao trong cùng một lần lặp. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds = ds.take(2).repeat(2) >>> list(ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] ``` #### to_csv[[datasets.IterableDataset.to_csv]] ```python to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4856) **Tham số:** path_or_buf (`PathLike` hoặc `FileOrBuffer`) : Một đường dẫn đến tệp (ví dụ: `file.csv`), một URI từ xa (ví dụ: `hf://datasets/username/my_dataset_name/data.csv`), hoặc một BinaryIO, nơi bộ dữ liệu sẽ được lưu trữ theo định dạng được chỉ định. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi lại một lúc. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. - ****to_csv_kwargs** (các tham số bổ sung): Các tham số để truyền cho [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) của pandas. Tham số `index` mặc định là `False` nếu không được chỉ định. Nếu bạn muốn ghi index, hãy truyền `index=True` và cũng đặt tên cho cột index bằng cách truyền `index_label`. **Trả về:** `int` Số lượng ký tự hoặc byte đã được ghi. Xuất bộ dữ liệu ra csv. Quá trình này lặp qua tập dữ liệu và tải toàn bộ vào bộ nhớ trước khi ghi ra. Ví dụ: ```py >>> ds.to_csv("path/to/dataset/directory") ``` #### to_pandas[[datasets.IterableDataset.to_pandas]] ```python to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4777) **Tham số:** batch_size (`int`, *tuỳ chọn*) : Kích thước (số dòng) của các lô nếu `batched` là `True`. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Đặt thành `True` để trả về một generator tạo ra dataset theo các lô gồm `batch_size` hàng. Mặc định là `False` (trả về toàn bộ dataset một lần). **Trả về:** `pandas.DataFrame` hoặc `Iterator[pandas.DataFrame]` Trả về tập dữ liệu dưới dạng `pandas.DataFrame`. Cũng có thể trả về một generator cho các tập dữ liệu lớn. Ví dụ: ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.IterableDataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4737) **Tham số:** batch_size (`int`, *tuỳ chọn*) : Kích thước (số dòng) của các lô nếu `batched` là `True`. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. **Trả về:** `dict` hoặc `Iterator[dict]` Trả về tập dữ liệu dưới dạng dict Python. Cũng có thể trả về một generator cho các tập dữ liệu lớn. Ví dụ: ```py >>> ds.to_dict() ``` #### to_json[[datasets.IterableDataset.to_json]] ```python to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4899) **Tham số:** path_or_buf (`PathLike` hoặc `FileOrBuffer`) : Một đường dẫn đến tệp (ví dụ: `file.json`), một URI từ xa (ví dụ: `hf://datasets/username/my_dataset_name/data.json`), hoặc một BinaryIO, nơi bộ dữ liệu sẽ được lưu trữ theo định dạng được chỉ định. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi lại một lúc. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. - ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`. **Trả về:** `int` Số lượng ký tự hoặc byte đã được ghi. Xuất dataset ra JSON Lines hoặc JSON. Quá trình này lặp qua tập dữ liệu và tải toàn bộ vào bộ nhớ trước khi ghi ra. Định dạng đầu ra mặc định là [JSON Lines](https://jsonlines.org/). Để xuất sang [JSON](https://www.json.org), hãy truyền tham số `lines=False` và `orient` mong muốn. Ví dụ: ```py >>> ds.to_json("path/to/dataset/directory/filename.jsonl") ``` ```py >>> num_shards = dataset.num_shards >>> for index in range(num_shards): ... shard = dataset.shard(index, num_shards) ... shard.to_json(f"path/of/my/dataset/data-{index:05d}.jsonl") ``` #### to_parquet[[datasets.IterableDataset.to_parquet]] ```python to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4995) **Tham số:** path_or_buf (`PathLike` hoặc `FileOrBuffer`) : Một đường dẫn đến tệp (ví dụ: `file.parquet`), một URI từ xa (ví dụ: `hf://datasets/username/my_dataset_name/data.parquet`), hoặc một BinaryIO, nơi bộ dữ liệu sẽ được lưu trữ theo định dạng được chỉ định. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi lại một lúc. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *tùy chọn*) : Các cặp key/value để truyền đến backend hệ thống tệp, nếu có. - ****parquet_writer_kwargs** (các tham số bổ sung): Các tham số để truyền cho `pyarrow.parquet.ParquetWriter` của PyArrow. **Trả về:** `int` Số lượng ký tự hoặc byte đã được ghi. Xuất bộ dữ liệu ra parquet Ví dụ: ```py >>> ds.to_parquet("path/to/dataset/directory") ``` ```py >>> num_shards = dataset.num_shards >>> for index in range(num_shards): ... shard = dataset.shard(index, num_shards) ... shard.to_parquet(f"path/of/my/dataset/data-{index:05d}.parquet") ``` #### to_sql[[datasets.IterableDataset.to_sql]] ```python to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, **sql_writer_kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4953) **Tham số:** name (`str`) : Tên bảng SQL. con (`str` hoặc `sqlite3.Connection` hoặc `sqlalchemy.engine.Connection` hoặc `sqlalchemy.engine.Connection`) : Một [chuỗi URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) hoặc một đối tượng kết nối SQLite3/SQLAlchemy được sử dụng để ghi vào cơ sở dữ liệu. batch_size (`int`, *optional*) : Kích thước của batch để nạp vào bộ nhớ và ghi lại một lúc. Mặc định là `datasets.config.DEFAULT_MAX_BATCH_SIZE`. - ****sql_writer_kwargs** (các tham số bổ sung): Các tham số để truyền cho [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) của pandas. Tham số `index` mặc định là `False` nếu không được chỉ định. Nếu bạn muốn ghi index, hãy truyền `index=True` và cũng đặt tên cho cột index bằng cách truyền `index_label`. **Trả về:** `int` Số lượng bản ghi đã được ghi. Xuất bộ dữ liệu ra cơ sở dữ liệu SQL. Ví dụ: ```py >>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con) ``` #### push_to_hub[[datasets.IterableDataset.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L5330) **Tham số:** repo_id (`str`) : ID của kho cần đẩy lên, theo định dạng: `/` hoặc `/`. Cũng chấp nhận ``, khi đó sẽ mặc định dùng namespace của người dùng đang đăng nhập. Cũng có thể là một vị trí bên trong bucket, ví dụ `buckets///...` config_name (`str`, mặc định là "default") : Tên cấu hình (hoặc tập con) của một bộ dữ liệu. Mặc định là "default". set_default (`bool`, *tùy chọn*) : Có nên đặt cấu hình này làm cấu hình mặc định hay không. Nếu không, cấu hình mặc định sẽ là cấu hình có tên "default". split (`str`, *tùy chọn*) : Tên của phần chia (split) sẽ được gán cho tập dữ liệu đó. Mặc định là `self.split`. data_dir (`str`, *tùy chọn*) : Tên thư mục sẽ chứa các tệp dữ liệu đã tải lên. Mặc định là `config_name` nếu khác "default", nếu không thì là "data". commit_message (`str`, *tùy chọn*) : Thông điệp để commit khi đẩy. Mặc định là `"Upload dataset"`. commit_description (`str`, *tùy chọn*) : Mô tả của commit sẽ được tạo. Ngoài ra, mô tả của PR nếu một PR được tạo (`create_pr` là True). private (`bool`, *tuỳ chọn*) : Có nên đặt kho thành riêng tư hay không. Nếu là `None` (mặc định), kho sẽ là công khai trừ khi mặc định của tổ chức là riêng tư. Giá trị này bị bỏ qua nếu kho đã tồn tại. token (`str`, *tùy chọn*) : Một token xác thực tùy chọn cho Hugging Face Hub. Nếu không truyền token, hệ thống sẽ mặc định sử dụng token được lưu cục bộ khi đăng nhập bằng `hf auth login`. Sẽ gây ra lỗi nếu không truyền token và người dùng chưa đăng nhập. revision (`str`, *tùy chọn*) : Nhánh để đẩy các tệp đã tải lên. Mặc định là nhánh `"main"`. create_pr (`bool`, *tùy chọn*, mặc định là `False`) : Có tạo PR với các tệp đã tải lên hay commit trực tiếp hay không. max_shard_size (`int` hoặc `str`, *tùy chọn*) : Kích thước tối đa tùy chọn của các shard dữ liệu sẽ được tải lên hub. Nếu được biểu diễn dưới dạng chuỗi, cần phải là các chữ số theo sau bởi một đơn vị (ví dụ `"5MB"`). Nếu không được cung cấp, số lượng shard mặc định sẽ là `.num_shards` của bộ dữ liệu này. num_shards (`int`, *optional*) : Số lượng shard cần ghi. Nếu `max_shard_size` được cung cấp và `num_shards` không được cung cấp, thì số lượng shard sẽ được ước tính từ `max_shard_size`. Giá trị này có thể lớn hơn `.num_shards` của tập dữ liệu này: khi đó, mỗi shard đầu vào sẽ được phân bổ sang nhiều shard đầu ra bằng cách ghi các ví dụ của nó vào chúng theo kiểu round-robin. embed_external_files (`bool`, mặc định là `True`) : Xác định có nhúng byte của tệp vào các shard hay không. Cụ thể, trước khi đẩy lên, thao tác này sẽ thực hiện các bước sau cho các trường có kiểu: - [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) và [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image): xóa thông tin đường dẫn cục bộ và nhúng nội dung tệp vào các tệp Parquet. num_proc (`int`, *optional*, mặc định là `None`) : Số lượng tiến trình khi chuẩn bị và tải lên bộ dữ liệu. Điều này hữu ích nếu bộ dữ liệu gồm nhiều mẫu và các phép biến đổi. I sử dụng ngữ cảnh "spawn" để làm việc với hf_xet, client rust cho việc tải lên HF nhanh chóng. Đa tiến trình bị vô hiệu hóa theo mặc định. **Trả về:** huggingface_hub.CommitInfo Đẩy dataset lên hub dưới dạng dataset Parquet. Dataset được đẩy bằng các yêu cầu HTTP và không cần cài đặt git hoặc git-lfs. Các tệp Parquet kết quả mặc định là tự chứa. Nếu tập dữ liệu của bạn chứa dữ liệu [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) hoặc [Video](/docs/datasets/main/vi/package_reference/main_classes#datasets.Video), các tệp Parquet sẽ lưu trữ các byte của tệp hình ảnh hoặc âm thanh của bạn. Bạn có thể tắt điều này bằng cách đặt `embed_external_files` thành `False`. Ví dụ: ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Nếu tập dữ liệu của bạn có nhiều phần chia (ví dụ: train/validation/test): ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Nếu bạn muốn thêm một cấu hình (hoặc tập con) mới vào một tập dữ liệu (ví dụ: nếu tập dữ liệu có nhiều tác bản/phân bản/ngôn ngữ): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### load_state_dict[[datasets.IterableDataset.load_state_dict]] ```python load_state_dict(state_dict: dict) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2800) Nạp state_dict của tập dữ liệu. Việc lặp sẽ bắt đầu lại từ ví dụ tiếp theo so với thời điểm trạng thái được lưu. Việc tiếp tục sẽ quay lại đúng vị trí mà checkpoint đã được lưu, ngoại trừ hai trường hợp: 1. các mẫu từ bộ đệm xáo trộn sẽ bị mất khi tiếp tục và các bộ đệm sẽ được nạp lại bằng dữ liệu mới 2. Các tổ hợp của `.with_format(arrow)` và `.map()` dạng batch có thể bỏ qua một batch. Ví dụ: ```py >>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example) ``` trả về: ``` {'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5} ``` ```py >>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood ``` #### state_dict[[datasets.IterableDataset.state_dict]] ```python state_dict() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2747) **Trả về:** `dict` Lấy state_dict hiện tại của dataset. Nó tương ứng với trạng thái tại ví dụ gần nhất mà nó đã tạo ra. Việc tiếp tục sẽ quay lại đúng vị trí mà checkpoint đã được lưu, ngoại trừ hai trường hợp: 1. các mẫu từ bộ đệm xáo trộn sẽ bị mất khi tiếp tục và các bộ đệm sẽ được nạp lại bằng dữ liệu mới 2. Các tổ hợp của `.with_format(arrow)` và `.map()` dạng batch có thể bỏ qua một batch. Ví dụ: ```py >>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example) ``` trả về: ``` {'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5} ``` ```py >>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood ``` #### info[[datasets.IterableDataset.info]] ```python info() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L172) đối tượng [DatasetInfo](/docs/datasets/main/vi/package_reference/main_classes#datasets.DatasetInfo) chứa tất cả các metadata trong dataset. #### split[[datasets.IterableDataset.split]] ```python split() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L177) đối tượng [NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit) tương ứng với một phần chia (split) có tên của tập dữ liệu. #### builder_name[[datasets.IterableDataset.builder_name]] ```python builder_name() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L182) #### trích dẫn[[datasets.IterableDataset.citation]] ```python citation() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.IterableDataset.config_name]] ```python config_name() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.IterableDataset.dataset_size]] ```python dataset_size() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L194) #### mô tả[[datasets.IterableDataset.description]] ```python description() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.IterableDataset.download_checksums]] ```python download_checksums() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.IterableDataset.download_size]] ```python download_size() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L206) #### tính năng[[datasets.IterableDataset.features]] ```python features() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L210) #### Trang chủ[[datasets.IterableDataset.homepage]] ```python homepage() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L214) #### Giấy phép[[datasets.IterableDataset.license]] ```python license() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.IterableDataset.size_in_bytes]] ```python size_in_bytes() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.IterableDataset.supervised_keys]] ```python supervised_keys() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L226) #### phiên bản[[datasets.IterableDataset.version]] ```python version() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L230) #### from_csv[[datasets.IterableDataset.from_csv]] ```python from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3392) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp CSV. split ([NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit), *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `pandas.read_csv`. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Tạo một IterableDataset từ tệp CSV. Ví dụ: ```py >>> ds = IterableDataset.from_csv('path/to/dataset.csv') ``` #### from_json[[datasets.IterableDataset.from_json]] ```python from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3435) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp JSON hoặc JSON Lines. split ([NamedSplit](/docs/datasets/main/vi/package_reference/builder_classes#datasets.NamedSplit), *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features ([Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features), *tùy chọn*) : Các tính năng của bộ dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. field (`str`, *tùy chọn*) : Tên trường của tệp JSON chứa bộ dữ liệu. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `JsonConfig`. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Tạo một IterableDataset từ tệp JSON hoặc JSON Lines. Ví dụ: ```py >>> ds = IterableDataset.from_json('path/to/dataset.json') ``` #### from_parquet[[datasets.IterableDataset.from_parquet]] ```python from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3482) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp Parquet. split (`NamedSplit`, *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features (`Features`, *tùy chọn*) : Các đặc trưng của tập dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. columns (`List[str]`, *tùy chọn*) : Nếu không phải `None`, chỉ các cột này sẽ được đọc từ tệp. Tên cột có thể là tiền tố của một trường lồng nhau, ví dụ 'a' sẽ chọn 'a.b', 'a.c' và 'a.d.e'. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *tùy chọn*) : Chỉ trả về các dòng khớp với bộ lọc. Nếu có thể, điều kiện sẽ được đẩy xuống để khai thác thông tin phân vùng hoặc siêu dữ liệu bên trong tìm thấy trong nguồn dữ liệu, ví dụ như thống kê Parquet. Nếu không, bộ lọc sẽ được áp dụng lên các RecordBatch đã tải trước khi chúng được trả về. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *tuỳ chọn*) : Các tuỳ chọn quét cụ thể cho các fragment Parquet. Điều này đặc biệt hữu ích để cấu hình đệm và bộ nhớ đệm. on_bad_files (`Literal["error", "warn", "skip"]`, *tùy chọn*, mặc định là "error") : Xác định cách xử lý khi gặp tệp lỗi (tệp không thể đọc được). Các giá trị được phép là : * 'error', ném một Exception khi gặp tệp lỗi. * 'warn', phát sinh một cảnh báo khi gặp tệp lỗi và bỏ qua tệp đó. * 'skip', bỏ qua các tệp lỗi mà không phát sinh ngoại lệ hay cảnh báo khi gặp chúng. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `ParquetConfig`. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Tạo một IterableDataset từ tệp Parquet. Ví dụ: ```py >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet') ``` Tải một tập con các cột: ```python >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Lọc dữ liệu một cách hiệu quả, có thể bỏ qua toàn bộ các tệp hoặc nhóm hàng: ```python >>> filters = [("col_0", "==", 0)] >>> ds = IterableDataset.from_parquet(parquet_files_list, filters=filters) ``` #### from_text[[datasets.IterableDataset.from_text]] ```python from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3567) **Tham số:** path_or_paths (`path-like` hoặc danh sách `path-like`) : Đường dẫn của tệp văn bản. split (`NamedSplit`, *tùy chọn*) : Tên phân chia sẽ được gán cho bộ dữ liệu. features (`Features`, *tùy chọn*) : Các đặc trưng của tập dữ liệu. keep_in_memory (`bool`, mặc định là `False`) : Có sao chép dữ liệu trong bộ nhớ hay không. keep_linebreaks : (`bool`, mặc định là False): Có giữ xuống dòng hay không. sample_by (`Literal["line", "paragraph", "document"]`, mặc định là "line") : Xác định việc nạp dữ liệu theo từng dòng, đoạn văn hay tài liệu. Mặc định, một hàng trong bộ dữ liệu tương ứng với một dòng. - ****kwargs** (các đối số từ khóa bổ sung) : Các đối số từ khóa được truyền đến `TextConfig`. **Trả về:** [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset) Tạo một IterableDataset từ tệp văn bản. Ví dụ: ```py >>> ds = IterableDataset.from_text('path/to/dataset.txt') ``` #### datasets.IterableColumn[[datasets.IterableColumn]] ```python datasets.IterableColumn(source: typing.Union[ForwardRef('IterableDataset'), ForwardRef('IterableColumn')], column_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2657) Một đối tượng lặp được cho một cột cụ thể của [IterableDataset](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset). Ví dụ: Lặp lại trên các văn bản của cột "text" của một tập dữ liệu: ```python for text in dataset["text"]: ... ``` Nó cũng hoạt động với các cột lồng nhau: ```python for source in dataset["metadata"]["source"]: ... ``` ## IterableDatasetDict[[datasets.IterableDatasetDict]] Từ điển có tên phân chia làm khóa (ví dụ: 'train', 'test') và các đối tượng `IterableDataset` làm giá trị. #### datasets.IterableDatasetDict[[datasets.IterableDatasetDict]] [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1810) #### map[[datasets.IterableDatasetDict.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: int = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, fn_kwargs: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1911) **Tham số:** function (`Callable`, *tùy chọn*, mặc định là `None`) : Hàm được áp dụng trực tiếp lên các ví dụ khi bạn lặp qua tập dữ liệu. Nó phải có một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> Dict[str, Any]` nếu `batched=False` và `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` nếu `batched=False` và `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` nếu `batched=True` và `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` nếu `batched=True` và `with_indices=True` Đối với cách sử dụng nâng cao, hàm cũng có thể trả về một `pyarrow.Table`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song. Hơn nữa, nếu hàm của bạn không trả về gì (`None`), thì `map` sẽ chạy hàm của bạn và trả về tập dữ liệu không thay đổi. Nếu không cung cấp hàm nào, mặc định là hàm đồng nhất: `lambda x: x`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx[, rank]): ...`. input_columns (`[Union[str, list[str]]]`, *tùy chọn*, mặc định là `None`) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một dict ánh xạ đến tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function`. batch_size (`int`, *tuỳ chọn*, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched=True`. drop_last_batch (`bool`, mặc định là `False`) : Xác định xem một batch cuối nhỏ hơn `batch_size` có nên bị loại bỏ thay vì được xử lý bởi hàm hay không. remove_columns (`[list[str]]`, *tùy chọn*, mặc định là `None`) : Loại bỏ một tập các cột khi thực hiện ánh xạ. Các cột sẽ bị loại bỏ trước khi cập nhật các ví dụ bằng kết quả đầu ra của `function`, tức là nếu `function` thêm các cột có tên nằm trong `remove_columns`, các cột này sẽ được giữ lại. fn_kwargs (`Dict`, *tùy chọn*, mặc định là `None`) : Các đối số từ khóa để truyền cho `function` Áp dụng một hàm lên tất cả các ví dụ trong tập dữ liệu dạng lặp (riêng lẻ hoặc theo lô) và cập nhật chúng. Nếu hàm của bạn trả về một cột đã tồn tại, nó sẽ ghi đè lên cột đó. Hàm được áp dụng trực tiếp lên các ví dụ khi lặp qua tập dữ liệu. Phép biến đổi được áp dụng lên tất cả các tập dữ liệu trong từ điển tập dữ liệu. Bạn có thể chỉ định xem hàm có nên được xử lý theo lô (batched) hay không bằng tham số `batched`: - Nếu `False`, thì hàm nhận vào 1 ví dụ và phải trả về 1 ví dụ. Một ví dụ là một từ điển, ví dụ `{"text": "Hello there !"}`. - Nếu `True` và `batch_size` là 1, thì hàm nhận vào một batch gồm 1 ví dụ và có thể trả về một batch gồm 1 hoặc nhiều hơn các ví dụ. Một batch là một từ điển, ví dụ một batch gồm 1 ví dụ là `{"text": ["Hello there !"]}`. - Nếu `True` và `batch_size` là `n` > 1, thì hàm nhận vào một batch gồm `n` ví dụ và có thể trả về một batch gồm `n` ví dụ, hoặc một số lượng ví dụ bất kỳ. Lưu ý rằng batch cuối cùng có thể có ít hơn `n` ví dụ. Một batch là một dictionary, ví dụ một batch gồm `n` ví dụ là `{"text": ["Hello there !"] * n}`. Nếu hàm là bất đồng bộ, thì `map` sẽ chạy hàm của bạn song song, với tối đa một nghìn cuộc gọi đồng thời. Khuyến nghị sử dụng `asyncio.Semaphore` trong hàm của bạn nếu bạn muốn đặt số lượng tối đa các thao tác có thể chạy cùng lúc. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> next(iter(ds["train"])) {'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### lọc[[datasets.IterableDatasetDict.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2011) **Tham số:** function (`Callable`) : Callable có một trong các chữ ký sau: - `function(example: Dict[str, Any]) -> bool` nếu `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` nếu `with_indices=True, batched=False` - `function(example: Dict[str, list]) -> list[bool]` nếu `with_indices=False, batched=True` - `function(example: Dict[str, list], indices: list[int]) -> list[bool]` nếu `with_indices=True, batched=True` Nếu không cung cấp hàm, mặc định là hàm luôn trả về True: `lambda x: True`. with_indices (`bool`, mặc định là `False`) : Cung cấp các chỉ mục ví dụ cho `function`. Lưu ý rằng trong trường hợp này, chữ ký của `function` phải là `def function(example, idx): ...`. input_columns (`str` hoặc `list[str]`, *tùy chọn*) : Các cột cần được truyền vào `function` dưới dạng các đối số vị trí. Nếu là `None`, một dict ánh xạ đến tất cả các cột đã được định dạng sẽ được truyền dưới dạng một đối số duy nhất. batched (`bool`, mặc định là `False`) : Cung cấp một lô ví dụ cho `function` batch_size (`int`, *tuỳ chọn*, mặc định là `1000`) : Số lượng ví dụ trong mỗi batch được cung cấp cho `function` nếu `batched=True`. fn_kwargs (`Dict`, *tùy chọn*, mặc định là `None`) : Các đối số từ khóa để truyền cho `function` Áp dụng một hàm lọc lên tất cả các phần tử để tập dữ liệu chỉ bao gồm các ví dụ theo hàm lọc đó. Việc lọc được thực hiện theo thời gian thực khi lặp qua tập dữ liệu. Bộ lọc được áp dụng cho tất cả các tập dữ liệu trong từ điển tập dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds["train"].take(3)) [{'label': 0, 'text': 'Review: simplistic , silly and tedious .'}, {'label': 0, 'text': "Review: it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'text': 'Review: exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}] ``` #### shuffle[[datasets.IterableDatasetDict.shuffle]] ```python shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2074) **Tham số:** seed (`int`, *tuỳ chọn*, mặc định là `None`) : Hạt ngẫu nhiên sẽ được sử dụng để xáo trộn bộ dữ liệu. Nó được dùng để lấy mẫu từ bộ đệm xáo trộn và cũng để xáo trộn các mảnh dữ liệu. generator (`numpy.random.Generator`, *tùy chọn*) : Numpy random Generator được sử dụng để tính hoán vị các dòng của tập dữ liệu. Nếu `generator=None` (mặc định), sẽ sử dụng `np.random.default_rng` (BitGenerator mặc định (PCG64) của NumPy). buffer_size (`int`, mặc định là `1000`) : Kích thước của bộ đệm. max_buffer_input_shards (`int`, mặc định là `10`) : Số lượng shard tối đa được sử dụng để nạp vào buffer mỗi lần. Trộn ngẫu nhiên các phần tử của tập dữ liệu này. Việc trộn được áp dụng cho tất cả các tập dữ liệu trong từ điển tập dữ liệu. Bộ dữ liệu này điền một bộ đệm với buffer_size phần tử, sau đó lấy mẫu ngẫu nhiên các phần tử từ bộ đệm này, thay thế các phần tử được chọn bằng các phần tử mới. Để xáo trộn hoàn hảo, kích thước bộ đệm phải lớn hơn hoặc bằng kích thước đầy đủ của bộ dữ liệu. Ví dụ, nếu tập dữ liệu của bạn chứa 10.000 phần tử nhưng `buffer_size` được đặt là 1000, thì `shuffle` ban đầu sẽ chọn một phần tử ngẫu nhiên chỉ từ 1000 phần tử đầu tiên trong bộ đệm. Khi một phần tử được chọn, vị trí của nó trong bộ đệm sẽ được thay thế bằng phần tử tiếp theo (tức là phần tử thứ 1.001), duy trì bộ đệm 1000 phần tử. Nếu tập dữ liệu được tạo từ nhiều shard, nó cũng thực hiện `shuffle` thứ tự của các shard. Tuy nhiên, nếu thứ tự đã được cố định bằng cách sử dụng [skip()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.skip) hoặc [take()](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDataset.take) thì thứ tự của các shard sẽ được giữ nguyên. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> list(ds["train"].take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.shuffle(seed=42) >>> list(ds["train"].take(3)) [{'label': 1, 'text': "a sports movie with action that's exciting on the field and a story you care about off it ."}, {'label': 1, 'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .'}, {'label': 1, 'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune ."}] ``` #### with_format[[datasets.IterableDatasetDict.with_format]] ```python with_format(type: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1865) **Tham số:** type (`str`, *tùy chọn*) : Kiểu đầu ra được chọn trong `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` có nghĩa là trả về các đối tượng python (mặc định). Trả về một tập dữ liệu với định dạng được chỉ định. Ví dụ: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation", streaming=True) >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds = ds.with_format("torch") >>> next(iter(ds)) {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### cast[[datasets.IterableDatasetDict.cast]] ```python cast(features: Features) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2290) **Tham số:** features (`Features`) : Các tính năng mới để chuyển đổi (cast) dataset sang. Tên của các trường trong features phải khớp với tên cột hiện tại. Kiểu dữ liệu cũng phải có thể chuyển đổi từ kiểu này sang kiểu khác. Đối với các phép chuyển đổi không đơn giản, ví dụ `string` <-> `ClassLabel`, bạn nên sử dụng `map` để cập nhật Dataset. **Trả về:** [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) Một bản sao của bộ dữ liệu với các đặc trưng đã được chuyển đổi kiểu. Đổ dataset sang một tập các đặc trưng mới. Việc chuyển kiểu được áp dụng cho tất cả các dataset trong từ điển dataset. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.IterableDatasetDict.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2259) **Tham số:** column (`str`) : Tên cột. feature (`Feature`) : Đặc trưng đích. **Trả về:** [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) Đổ cột xuống dạng feature để giải mã. Việc chuyển kiểu được áp dụng cho tất cả các dataset trong từ điển dataset. Ví dụ: ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.IterableDatasetDict.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2207) **Tham số:** column_names (`Union[str, list[str]]`) : Tên của cột (các cột) cần xóa. **Trả về:** [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) Một bản sao của đối tượng bộ dữ liệu không bao gồm các cột cần xóa. Xóa một hoặc nhiều cột trong dataset và các đặc trưng liên quan đến chúng. Việc xóa được thực hiện trực tiếp trên các ví dụ khi lặp qua dataset. Việc xóa được áp dụng cho tất cả các dataset trong từ điển dataset. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.remove_columns("label") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### rename_column[[datasets.IterableDatasetDict.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2143) **Tham số:** original_column_name (`str`) : Tên của cột cần đổi tên. new_column_name (`str`) : Tên mới cho cột. **Trả về:** [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) Một bản sao của bộ dữ liệu với một cột đã được đổi tên. Đổi tên một cột trong bộ dữ liệu và di chuyển các đặc trưng liên quan đến cột gốc sang dưới tên cột mới. Việc đổi tên được áp dụng cho tất cả các bộ dữ liệu trong từ điển bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds["train"])) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### rename_columns[[datasets.IterableDatasetDict.rename_columns]] ```python rename_columns(column_mapping: dict) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2179) **Tham số:** column_mapping (`Dict[str, str]`) : Bản ánh xạ từ các cột cần đổi tên sang tên mới của chúng. **Trả về:** [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) Một bản sao của bộ dữ liệu với các cột đã được đổi tên Đổi tên một số cột trong bộ dữ liệu và di chuyển các đặc trưng liên quan đến các cột gốc sang dưới tên cột mới. Việc đổi tên được áp dụng cho tất cả các bộ dữ liệu trong từ điển bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.rename_columns({"text": "movie_review", "label": "rating"}) >>> next(iter(ds["train"])) {'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'rating': 1} ``` #### select_columns[[datasets.IterableDatasetDict.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2233) **Tham số:** column_names (`Union[str, list[str]]`) : Tên của cột (các cột) cần giữ lại. **Trả về:** [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) Một bản sao của đối tượng bộ dữ liệu chỉ chứa các cột được chọn. Chọn một hoặc nhiều cột trong bộ dữ liệu cùng các đặc trưng liên quan đến chúng. Việc chọn lọc được thực hiện trực tiếp trên các ví dụ khi lặp qua bộ dữ liệu. Việc chọn lọc được áp dụng cho tất cả các bộ dữ liệu trong từ điển bộ dữ liệu. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.select("text") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### push_to_hub[[datasets.IterableDatasetDict.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2327) **Tham số:** repo_id (`str`) : ID của kho cần đẩy lên, theo định dạng: `/` hoặc `/`. Cũng chấp nhận ``, khi đó sẽ mặc định dùng namespace của người dùng đang đăng nhập. Cũng có thể là một vị trí bên trong bucket, ví dụ `buckets///...` config_name (`str`) : Tên cấu hình của một tập dữ liệu. Mặc định là "default". set_default (`bool`, *tùy chọn*) : Có nên đặt cấu hình này làm cấu hình mặc định hay không. Nếu không, cấu hình mặc định sẽ là cấu hình có tên "default". data_dir (`str`, *tùy chọn*) : Tên thư mục sẽ chứa các tệp dữ liệu đã tải lên. Mặc định là `config_name` nếu khác "default", nếu không thì là "data". commit_message (`str`, *tùy chọn*) : Thông điệp để commit khi đẩy. Mặc định là `"Upload dataset"`. commit_description (`str`, *tùy chọn*) : Mô tả của commit sẽ được tạo. Ngoài ra, mô tả của PR nếu một PR được tạo (`create_pr` là True). private (`bool`, *tuỳ chọn*) : Có nên đặt kho thành riêng tư hay không. Nếu là `None` (mặc định), kho sẽ là công khai trừ khi mặc định của tổ chức là riêng tư. Giá trị này bị bỏ qua nếu kho đã tồn tại. token (`str`, *tùy chọn*) : Một token xác thực tùy chọn cho Hugging Face Hub. Nếu không truyền token, hệ thống sẽ mặc định sử dụng token được lưu cục bộ khi đăng nhập bằng `hf auth login`. Sẽ gây ra lỗi nếu không truyền token và người dùng chưa đăng nhập. revision (`str`, *tùy chọn*) : Nhánh để đẩy các tệp đã tải lên. Mặc định là nhánh `"main"`. create_pr (`bool`, *tùy chọn*, mặc định là `False`) : Có tạo PR với các tệp đã tải lên hay commit trực tiếp hay không. max_shard_size (`int` hoặc `str`, *tùy chọn*) : Kích thước tối đa tùy chọn của các shard dữ liệu sẽ được tải lên hub. Nếu được biểu diễn dưới dạng chuỗi, cần phải là các chữ số theo sau bởi một đơn vị (như `"500MB"` hoặc `"1GB"`). Nếu không được cung cấp, mỗi split sẽ giữ nguyên số lượng shard gốc của bộ dữ liệu. num_shards (`Dict[str, int]`, *tùy chọn*) : Số lượng shard cần ghi. Sử dụng từ điển để định nghĩa `num_shards` khác nhau cho từng split. Nếu `max_shard_size` được cung cấp và `num_shards` của một split không được cung cấp, thì số lượng shard cho split đó sẽ được ước tính từ `max_shard_size`. embed_external_files (`bool`, mặc định là `True`) : Xác định có nhúng byte của tệp vào các shard hay không. Cụ thể, trước khi đẩy lên, thao tác này sẽ thực hiện các bước sau cho các trường có kiểu: - [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) và [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image) sẽ xóa thông tin đường dẫn cục bộ và nhúng nội dung tệp vào các tệp Parquet. num_proc (`int`, *optional*, mặc định là `None`) : Số lượng tiến trình khi chuẩn bị và tải lên bộ dữ liệu. Điều này hữu ích nếu bộ dữ liệu gồm nhiều mẫu hoặc tệp phương tiện cần nhúng. I sử dụng ngữ cảnh "spawn" để hoạt động với hf_xet, client rust cho việc tải lên HF nhanh chóng. Đa tiến trình bị vô hiệu hóa theo mặc định. **Trả về:** huggingface_hub.CommitInfo Đẩy [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) lên hub dưới dạng tập dữ liệu Parquet. [IterableDatasetDict](/docs/datasets/main/vi/package_reference/main_classes#datasets.IterableDatasetDict) được đẩy bằng các yêu cầu HTTP và không cần cài đặt git hoặc git-lfs. Mỗi phần chia của bộ dữ liệu sẽ được đẩy lên độc lập. Bộ dữ liệu được đẩy lên sẽ giữ nguyên tên các phần chia ban đầu. Các tệp Parquet kết quả mặc định là tự chứa: nếu tập dữ liệu của bạn chứa dữ liệu [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image) hoặc [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio), các tệp Parquet sẽ lưu trữ các byte của hình ảnh hoặc tệp âm thanh của bạn. Bạn có thể tắt điều này bằng cách đặt `embed_external_files` thành False. Ví dụ: ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Nếu bạn muốn thêm một cấu hình (hoặc tập con) mới vào một tập dữ liệu (ví dụ: nếu tập dữ liệu có nhiều tác bản/phân bản/ngôn ngữ): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` ## Tính năng[[datasets.Features]] #### datasets.Features[[datasets.Features]] ```python datasets.Features(*args, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1923) Một từ điển đặc biệt định nghĩa cấu trúc bên trong của một tập dữ liệu. Được khởi tạo bằng một từ điển có kiểu `dict[str, FieldType]`, trong đó các khóa là tên cột mong muốn và các giá trị là kiểu của cột đó. `FieldType` có thể là một trong các giá trị sau: - Tính năng [Value](/docs/datasets/main/vi/package_reference/main_classes#datasets.Value) chỉ định một giá trị kiểu dữ liệu đơn, ví dụ `int64` hoặc `string`. - Đặc trưng [ClassLabel](/docs/datasets/main/vi/package_reference/main_classes#datasets.ClassLabel) chỉ định một tập hợp các lớp được định nghĩa trước, có thể gắn nhãn cho chúng và sẽ được lưu dưới dạng số nguyên trong bộ dữ liệu. - `dict` của Python chỉ định một đặc trưng tổ hợp chứa ánh xạ từ các trường con đến các đặc trưng con. Có thể có các trường con lồng nhau trong các trường con theo cách tùy ý. - [List](/docs/datasets/main/vi/package_reference/main_classes#datasets.List) hoặc [LargeList](/docs/datasets/main/vi/package_reference/main_classes#datasets.LargeList) chỉ định một đặc trưng tổ hợp chứa một chuỗi các đặc trưng con, tất cả cùng một kiểu đặc trưng. - [Array2D](/docs/datasets/main/vi/package_reference/main_classes#datasets.Array2D), [Array3D](/docs/datasets/main/vi/package_reference/main_classes#datasets.Array3D), [Array4D](/docs/datasets/main/vi/package_reference/main_classes#datasets.Array4D) hoặc [Array5D](/docs/datasets/main/vi/package_reference/main_classes#datasets.Array5D) cho mảng nhiều chiều. - [Audio](/docs/datasets/main/vi/package_reference/main_classes#datasets.Audio) là tính năng để lưu trữ đường dẫn tuyệt đối đến một tệp âm thanh hoặc một từ điển chứa đường dẫn tương đối đến tệp âm thanh (khóa "path") và nội dung byte của nó (khóa "bytes"). Tính năng này nạp âm thanh một cách lười biếng bằng một trình giải mã. - [Image](/docs/datasets/main/vi/package_reference/main_classes#datasets.Image) để lưu trữ đường dẫn tuyệt đối đến tệp ảnh, một đối tượng `np.ndarray`, một đối tượng `PIL.Image.Image` hoặc một từ điển chứa đường dẫn tương đối đến tệp ảnh (khóa "path") và nội dung byte của nó (khóa "bytes"). Tính năng này trích xuất dữ liệu ảnh. - [Video](/docs/datasets/main/vi/package_reference/main_classes#datasets.Video) là tính năng để lưu trữ đường dẫn tuyệt đối đến tệp video, một đối tượng `torchcodec.decoders.VideoDecoder` hoặc một từ điển chứa đường dẫn tương đối đến tệp video (khóa "path") và nội dung byte của nó (khóa "bytes"). Tính năng này tải video một cách lười biếng bằng trình giải mã. - [Pdf](/docs/datasets/main/vi/package_reference/main_classes#datasets.Pdf) là tính năng để lưu trữ đường dẫn tuyệt đối đến tệp PDF, một đối tượng `pdfplumber.pdf.PDF` hoặc một từ điển chứa đường dẫn tương đối đến tệp PDF (khóa "path") và nội dung byte của nó (khóa "bytes"). Tính năng này nạp PDF một cách lười biếng bằng trình đọc PDF. - [Nifti](/docs/datasets/main/vi/package_reference/main_classes#datasets.Nifti) là tính năng để lưu trữ đường dẫn tuyệt đối đến tệp hình ảnh thần kinh NIfTI, một đối tượng `nibabel.Nifti1Image` hoặc một từ điển chứa đường dẫn tương đối đến tệp NIfTI (khóa "path") và nội dung byte của nó (khóa "bytes"). Tính năng này nạp tệp NIfTI một cách lười biếng bằng nibabel. - [Translation](/docs/datasets/main/vi/package_reference/main_classes#datasets.Translation) hoặc [TranslationVariableLanguages](/docs/datasets/main/vi/package_reference/main_classes#datasets.TranslationVariableLanguages) là tính năng đặc thù cho Machine Translation. - [Json](/docs/datasets/main/vi/package_reference/loading_methods#datasets.Json) để lưu trữ dữ liệu không có cấu trúc, ví dụ như chứa các kiểu dữ liệu hỗn hợp/ngẫu nhiên. Bên trong #### copy[[datasets.Features.copy]] ```python copy() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2356) **Trả về:** [Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features) Tạo bản sao sâu của [Features](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features). Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> copy_of_features = ds.features.copy() >>> copy_of_features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} ``` #### decode_batch[[datasets.Features.decode_batch]] ```python decode_batch(batch: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2329) **Tham số:** batch (`dict[str, list[Any]]`) : Dữ liệu lô của tập dữ liệu. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp âm thanh hoặc hình ảnh từ các kho riêng tư trên Hub, bạn có thể truyền một từ điển repo_id (str) -> token (bool hoặc str) **Trả về:** `dict[str, list[Any]]` Giải mã batch với giải mã đặc trưng tùy chỉnh. #### decode_column[[datasets.Features.decode_column]] ```python decode_column(column: list, column_name: str, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2304) **Tham số:** column (`list[Any]`) : Dữ liệu cột của Dataset. column_name (`str`) : Tên cột của Dataset. **Trả về:** `list[Any]` Giải mã cột với giải mã đặc trưng tùy chỉnh. #### decode_example[[datasets.Features.decode_example]] ```python decode_example(example: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2281) **Tham số:** example (`dict[str, Any]`) : Dữ liệu hàng của Dataset. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp âm thanh hoặc hình ảnh từ các kho riêng tư trên Hub, bạn có thể truyền một từ điển `repo_id (str) -> token (bool or str)`. **Trả về:** `dict[str, Any]` Ví dụ giải mã với giải mã đặc trưng tùy chỉnh. #### encode_batch[[datasets.Features.encode_batch]] ```python encode_batch(batch) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2262) **Tham số:** batch (`dict[str, list[Any]]`) : Dữ liệu trong một batch của Dataset. **Trả về:** `dict[str, list[Any]]` Mã hóa batch thành định dạng cho Arrow. #### encode_column[[datasets.Features.encode_column]] ```python encode_column(column, column_name: str) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2246) **Tham số:** column (`list[Any]`) : Dữ liệu trong một cột của Dataset. column_name (`str`) : Tên cột của Dataset. **Trả về:** `list[Any]` Mã hóa cột thành định dạng cho Arrow. #### encode_example[[datasets.Features.encode_example]] ```python encode_example(example) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2232) **Tham số:** example (`dict[str, Any]`) : Dữ liệu trong một hàng của Dataset. **Trả về:** `dict[str, Any]` Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.Features.flatten]] ```python flatten(max_depth = 16) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2429) **Trả về:** [Features](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features) Các đặc trưng đã được làm phẳng. Dàn phẳng các đặc trưng. Mỗi cột từ điển sẽ bị xóa và được thay thế bằng tất cả các trường con mà nó chứa. Các trường mới được đặt tên bằng cách nối tên của cột gốc và tên trường con theo cách này: `.`. Nếu một cột chứa các từ điển lồng nhau, thì tất cả tên các trường con ở cấp thấp hơn cũng được nối lại để tạo thành các cột mới: `..`, v.v. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad", split="train") >>> ds.features.flatten() {'answers.answer_start': List(Value('int32'), id=None), 'answers.text': List(Value('string'), id=None), 'context': Value('string'), 'id': Value('string'), 'question': Value('string'), 'title': Value('string')} ``` #### from_arrow_schema[[datasets.Features.from_arrow_schema]] ```python from_arrow_schema(pa_schema: Schema) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2015) **Tham số:** pa_schema (`pyarrow.Schema`) : Schema Arrow. **Trả về:** [Tính năng](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features) Xây dựng [Features](/docs/datasets/main/vi/package_reference/main_classes#datasets.Features) từ Arrow Schema. Nó cũng kiểm tra metadata của schema đối với các features của Hugging Face Datasets. Các trường không nullable không được hỗ trợ và sẽ được đặt thành nullable. Ngoài ra, pa.dictionary không được hỗ trợ và thay vào đó sẽ sử dụng kiểu dữ liệu cơ bản của nó. Do đó, datasets sẽ chuyển đổi các đối tượng DictionaryArray thành giá trị thực của chúng. #### from_dict[[datasets.Features.from_dict]] ```python from_dict(dic) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2049) **Tham số:** dic (*dict[str, Any]*) : Từ điển Python. **Trả về:** `*Features*` Xây dựng [*Features*] từ dict. Tạo lại đối tượng đặc trưng lồng nhau từ một dict đã được khử chuỗi hóa. Chúng ta sử dụng khóa *_type* để suy ra tên dataclass của đặc trưng *FieldType*. Nó cho phép sử dụng cú pháp constructor tiện lợi để định nghĩa các đặc trưng từ các từ điển JSON đã được khử chuỗi hóa. Hàm này đặc biệt được sử dụng khi khử chuỗi hóa một [*DatasetInfo*] đã được xuất ra thành một đối tượng JSON. Nó đóng vai trò tương đương với [*Features.from_arrow_schema*] và xử lý việc khởi tạo đệ quy từng trường một, nhưng không yêu cầu bất kỳ ánh xạ nào tới/đi từ pyarrow, ngoại trừ việc tận dụng ánh xạ các kiểu dữ liệu nguyên thủy của pyarrow mà [*Value*] tự động thực hiện. Ví dụ: ```python >>> Features.from_dict(&lcub;'_type': &lcub;'dtype': 'string', 'id': None, '_type': 'Value'}}) &lcub;'_type': Value('string')} ``` #### reorder_fields_as[[datasets.Features.reorder_fields_as]] ```python reorder_fields_as(other: Features) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2376) **Tham số:** other ([*Các tính năng*]) : Các [*tính năng*] khác cần căn chỉnh. **Trả về:** [*Tính năng*] Sắp xếp lại các trường Features để khớp với thứ tự trường của các [*Features*] khác. Thứ tự của các trường là quan trọng vì nó ảnh hưởng đến dữ liệu arrow bên dưới. Việc sắp xếp lại các trường cho phép kiểu dữ liệu arrow bên dưới khớp nhau. Ví dụ: ```python >>> from datasets import Features, List, Value >>> # let's say we have two features with a different order of nested fields (for a and b for example) >>> f1 = Features(&lcub;"root": &lcub;"a": Value("string"), "b": Value("string")}}) >>> f2 = Features(&lcub;"root": &lcub;"b": Value("string"), "a": Value("string")}}) >>> assert f1.type != f2.type >>> # re-ordering keeps the base structure (here List is defined at the root level), but makes the fields order match >>> f1.reorder_fields_as(f2) &lcub;'root': List(&lcub;'b': Value('string'), 'a': Value('string')})} >>> assert f1.reorder_fields_as(f2).type == f2.type ``` ### Scalar[[datasets.Value]] #### datasets.Value[[datasets.Value]] ```python datasets.Value(dtype: str, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L511) **Tham số:** dtype (`str`) : Tên của kiểu dữ liệu. Giá trị đặc trưng vô hướng của một kiểu dữ liệu cụ thể. Các dtype có thể của `Value` như sau: - `null` - `bool` - `int8` - `int16` - `int32` - `int64` - `uint8` - `uint16` - `uint32` - `uint64` - `float16` - `float32` (biệt danh float) - `float64` (biệt danh double) - `time32[(s|ms)]` - `time64[(us|ns)]` - `timestamp[(s|ms|us|ns)]` - `timestamp[(s|ms|us|ns), tz=(tzstring)]` - `date32` - `date64` - `duration[(s|ms|us|ns)]` - `decimal128(precision, scale)` - `decimal256(precision, scale)` - `binary` - `large_binary` - `binary_view` - `string` - `large_string` - `string_view` Ví dụ: ```py >>> from datasets import Features >>> features = Features({'stars': Value('int32')}) >>> features {'stars': Value('int32')} ``` #### datasets.ClassLabel[[datasets.ClassLabel]] ```python datasets.ClassLabel(num_classes: dataclasses.InitVar[typing.Optional[int]] = None, names: list = None, names_file: dataclasses.InitVar[typing.Optional[str]] = None, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1052) **Tham số:** num_classes (`int`, *optional*) : Số lượng lớp. Tất cả nhãn phải < `num_classes`. names (`list` của `str`, *tùy chọn*) : Tên chuỗi cho các lớp số nguyên. Thứ tự cung cấp các tên được giữ nguyên. names_file (`str`, *tùy chọn*) : Đường dẫn đến tệp chứa tên của các lớp số nguyên, mỗi dòng một tên. Loại đặc trưng cho nhãn lớp nguyên. Có 3 cách để định nghĩa một `ClassLabel`, tương ứng với 3 tham số: * `num_classes`: Tạo các nhãn từ 0 đến (num_classes-1). * `names`: Danh sách các chuỗi nhãn. * `names_file`: Tệp chứa danh sách các nhãn. Bên trong, các nhãn được lưu trữ dưới dạng số nguyên. Bạn có thể sử dụng -1 để biểu diễn các nhãn không xác định/thiếu. Ví dụ: ```py >>> from datasets import Features, ClassLabel >>> features = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])}) >>> features {'label': ClassLabel(names=['bad', 'ok', 'good'])} ``` #### cast_storage[[datasets.ClassLabel.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1217) **Tham số:** storage (`Union[pa.StringArray, pa.IntegerArray]`) : mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.Int64Array` Array trong kiểu lưu trữ arrow của `ClassLabel`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow `ClassLabel`. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow `ClassLabel` là: - `pa.string()` - `pa.int()` #### int2str[[datasets.ClassLabel.int2str]] ```python int2str(values: typing.Union[int, collections.abc.Iterable]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1171) Chuyển đổi `integer` => chuỗi tên lớp `string`. Về nhãn không xác định/thiếu: truyền các số nguyên âm sẽ gây ra `ValueError`. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].int2str(0) 'neg' ``` #### str2int[[datasets.ClassLabel.str2int]] ```python str2int(values: typing.Union[str, collections.abc.Iterable]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1126) Tên lớp chuyển đổi `string` => `integer`. Ví dụ: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].str2int('neg') 0 ``` ### Composite[[datasets.LargeList]] #### datasets.LargeList[[datasets.LargeList]] ```python datasets.LargeList(feature: typing.Any, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1406) **Tham số:** feature (`FeatureType`) : Kiểu dữ liệu của tính năng con của từng mục trong danh sách lớn. Loại đặc trưng cho dữ liệu danh sách lớn được cấu thành từ loại dữ liệu đặc trưng con. Nó được hỗ trợ bởi `pyarrow.LargeListType`, tương tự như `pyarrow.ListType` nhưng sử dụng offset 64-bit thay vì 32-bit. #### datasets.List[[datasets.List]] ```python datasets.List(feature: typing.Any, length: int = -1, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1378) **Tham số:** feature (`FeatureType`) : Kiểu dữ liệu của tính năng con của từng mục trong danh sách lớn. length (tùy chọn `int`, mặc định là -1) : Độ dài của danh sách nếu nó cố định. Mặc định là -1, có nghĩa là độ dài tùy ý. Loại đặc trưng cho dữ liệu danh sách lớn được cấu thành từ loại dữ liệu đặc trưng con. Nó được hỗ trợ bởi `pyarrow.ListType`, sử dụng các offset 32-bit hoặc một độ dài cố định. #### datasets.Sequence[[datasets.Sequence]] ```python datasets.Sequence(feature = None, length = -1, **kwargs) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1344) **Tham số:** feature (`FeatureType`) : Kiểu dữ liệu của tính năng con của từng mục trong danh sách lớn. length (tùy chọn `int`, mặc định là -1) : Độ dài của danh sách nếu nó cố định. Mặc định là -1, có nghĩa là độ dài tùy ý. **Trả về:** [Danh sách](/docs/datasets/main/vi/package_reference/main_classes#datasets.List) của tính năng được chỉ định, ngoại trừ `dict` của các tính năng con, vốn được chuyển đổi thành `dict` của các danh sách tính năng con để tương thích với TFDS. Một `Sequence` là tiện ích tự động chuyển đổi đặc trưng từ điển nội bộ thành từ điển các danh sách. Hành vi này được triển khai để có lớp tương thích với thư viện TensorFlow Datasets nhưng có thể không mong muốn trong một số trường hợp. Nếu bạn không muốn hành vi này, bạn có thể sử dụng [List](/docs/datasets/main/vi/package_reference/main_classes#datasets.List) hoặc [LargeList](/docs/datasets/main/vi/package_reference/main_classes#datasets.LargeList) thay vì [Sequence](/docs/datasets/main/vi/package_reference/main_classes#datasets.Sequence). ### Bản dịch[[datasets.Translation]] #### datasets.Translation[[datasets.Translation]] ```python datasets.Translation(languages: list, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L12) **Tham số:** languages (`dict`) : Một từ điển cho mỗi ví dụ, ánh xạ các mã ngôn ngữ dạng chuỗi sang các bản dịch dạng chuỗi. `Feature` cho các bản dịch với ngôn ngữ cố định cho từng ví dụ. Ở đây để tương thích với tfds. Ví dụ: ```python >>> # At construction time: >>> datasets.features.Translation(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': 'le chat', ... 'de': 'die katze' ... } ``` #### flatten[[datasets.Translation.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L44) Phẳng hóa tính năng Translation thành một từ điển. #### datasets.TranslationVariableLanguages[[datasets.TranslationVariableLanguages]] ```python datasets.TranslationVariableLanguages(languages: typing.Optional[list] = None, num_languages: typing.Optional[int] = None, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L52) **Tham số:** languages (`dict`) : Một từ điển cho mỗi ví dụ, ánh xạ các mã ngôn ngữ dạng chuỗi sang một hoặc nhiều bản dịch dạng chuỗi. Các ngôn ngữ có mặt có thể khác nhau giữa các ví dụ. **Trả về:** - `language` hoặc `translation` (`tf.Tensor` 1 chiều có độ dài thay đổi của `tf.string`) Mã ngôn ngữ được sắp xếp theo thứ tự tăng dần hoặc các bản dịch dạng văn bản thuần túy, được sắp xếp để khớp với mã ngôn ngữ. `Feature` cho các bản dịch với ngôn ngữ khác nhau cho từng ví dụ. Ở đây để tương thích với tfds. Ví dụ: ```python >>> # At construction time: >>> datasets.features.TranslationVariableLanguages(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': ['le chat', 'la chatte,'] ... 'de': 'die katze' ... } >>> # Tensor returned : >>> { ... 'language': ['en', 'de', 'fr', 'fr'], ... 'translation': ['the cat', 'die katze', 'la chatte', 'le chat'], ... } ``` #### flatten[[datasets.TranslationVariableLanguages.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L122) Phẳng hóa tính năng TranslationVariableLanguages thành một từ điển. ### Mảng[[datasets.Array2D]] #### datasets.Array2D[[datasets.Array2D]] ```python datasets.Array2D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L608) **Tham số:** shape (`tuple`) : Kích thước của mỗi chiều. dtype (`str`) : Tên của kiểu dữ liệu. Tạo một mảng hai chiều. Ví dụ: ```py >>> from datasets import Features >>> features = Features({'x': Array2D(shape=(1, 3), dtype='int32')}) ``` #### datasets.Array3D[[datasets.Array3D]] ```python datasets.Array3D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L633) **Tham số:** shape (`tuple`) : Kích thước của mỗi chiều. dtype (`str`) : Tên của kiểu dữ liệu. Tạo một mảng ba chiều. Ví dụ: ```py >>> from datasets import Features >>> features = Features({'x': Array3D(shape=(1, 2, 3), dtype='int32')}) ``` #### datasets.Array4D[[datasets.Array4D]] ```python datasets.Array4D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L658) **Tham số:** shape (`tuple`) : Kích thước của mỗi chiều. dtype (`str`) : Tên của kiểu dữ liệu. Tạo một mảng bốn chiều. Ví dụ: ```py >>> from datasets import Features >>> features = Features({'x': Array4D(shape=(1, 2, 2, 3), dtype='int32')}) ``` #### datasets.Array5D[[datasets.Array5D]] ```python datasets.Array5D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L683) **Tham số:** shape (`tuple`) : Kích thước của mỗi chiều. dtype (`str`) : Tên của kiểu dữ liệu. Tạo một mảng năm chiều. Ví dụ: ```py >>> from datasets import Features >>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')}) ``` ### Âm thanh[[datasets.Audio]] #### datasets.Audio[[datasets.Audio]] ```python datasets.Audio(sampling_rate: typing.Optional[int] = None, decode: bool = True, num_channels: typing.Optional[int] = None, stream_index: typing.Optional[int] = None, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L24) **Tham số:** sampling_rate (`int`, *optional*) : Tốc độ lấy mẫu đích. Nếu là `None`, sẽ sử dụng tốc độ lấy mẫu gốc. num_channels (`int`, *optional*) : Số kênh mong muốn của các mẫu. Mặc định, số kênh của nguồn được sử dụng. Giải mã âm thanh sẽ trả về các mẫu có hình dạng (num_channels, num_samples) Hiện tại hỗ trợ `None` (số kênh của nguồn, mặc định), `1` (mono) hoặc `2` (stereo) kênh. Tham số `num_channels` được truyền đến `torchcodec.decoders.AudioDecoder`. decode (`bool`, mặc định là `True`) : Có giải mã dữ liệu âm thanh hay không. Nếu `False`, sẽ trả về từ điển gốc ở định dạng `{"path": audio_path, "bytes": audio_bytes}`. stream_index (`int`, *optional*) : Chỉ số streaming cần sử dụng từ tệp. Nếu là `None`, mặc định sẽ dùng chỉ số "tốt nhất". Audio `Feature` để trích xuất dữ liệu âm thanh từ một tệp âm thanh. Đầu vào: Tính năng Âm thanh chấp nhận các đầu vào sau: - Một `str`: Đường dẫn tuyệt đối đến tệp âm thanh (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp âm thanh (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp âm thanh so với tệp lưu trữ. - `bytes`: Bytes content of the audio file. Điều này hữu ích cho các tệp parquet hoặc webdataset có nhúng tệp âm thanh. - Một `dict` với các khóa: - `array`: Mảng chứa mẫu âm thanh - `sampling_rate`: Số nguyên tương ứng với tần số lấy mẫu của mẫu âm thanh. - Một `torchcodec.decoders.AudioDecoder`: đối tượng trình giải mã âm thanh của torchcodec. Đầu ra: Dữ liệu đầu ra của tính năng Âm thanh dưới dạng các đối tượng `torchcodec.decoders.AudioDecoder`, kèm theo các khóa bổ sung: - `array`: Mảng chứa mẫu âm thanh - `sampling_rate`: Số nguyên tương ứng với tần số lấy mẫu của mẫu âm thanh. Ví dụ: ```py >>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train") >>> ds = ds.cast_column("audio", Audio(sampling_rate=44100, num_channels=2)) >>> ds[0]["audio"] >>> audio = ds[0]["audio"] >>> audio.get_samples_played_in_range(0, 10) AudioSamples: data (shape): torch.Size([2, 110592]) pts_seconds: 0.0 duration_seconds: 2.507755102040816 sample_rate: 44100 ``` #### cast_storage[[datasets.Audio.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L237) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray]`) : Mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của Audio, đó là `pa.struct({"bytes": pa.binary(), "path": pa.string()})` Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow Audio. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow Audio là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.binary()` - phải chứa các byte âm thanh - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng #### decode_example[[datasets.Audio.decode_example]] ```python decode_example(value: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L164) **Tham số:** value (`dict`) : Một từ điển với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp âm thanh. - `bytes`: Dữ liệu của tệp âm thanh. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp âm thanh từ các kho riêng tư trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`) **Trả về:** `torchcodec.decoders.AudioDecoder` Giải mã tệp âm thanh mẫu thành dữ liệu âm thanh. #### embed_storage[[datasets.Audio.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L283) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nhúng dữ liệu tệp cục bộ vào mảng hay không remote_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp từ xa vào mảng hay không. Ví dụ: các tệp có đường dẫn bắt đầu bằng hf:// hoặc https:// **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của Audio, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Nhúng các tệp âm thanh vào mảng Arrow. #### encode_example[[datasets.Audio.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L96) **Tham số:** value (`str`, `bytes`,`bytearray`,`dict`, `AudioDecoder`) : Dữ liệu được truyền vào làm đầu vào cho tính năng Âm thanh. **Trả về:** `dict` Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.Audio.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L226) Nếu đang ở trạng thái có thể giải mã, hãy ném ra một lỗi, ngược lại hãy làm phẳng đặc trưng thành một từ điển. ### Hình ảnh[[datasets.Image]] #### datasets.Image[[datasets.Image]] ```python datasets.Image(mode: typing.Optional[str] = None, decode: bool = True, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L47) **Tham số:** mode (`str`, *tùy chọn*) : Chế độ để chuyển đổi hình ảnh. Nếu là `None`, chế độ gốc của hình ảnh sẽ được sử dụng. decode (`bool`, mặc định là `True`) : Có giải mã dữ liệu hình ảnh hay không. Nếu `False`, sẽ trả về từ điển cơ bản ở định dạng `{"path": image_path, "bytes": image_bytes}`. `Feature` hình ảnh để đọc dữ liệu hình ảnh từ tệp hình ảnh. Đầu vào: Tính năng Image nhận các đầu vào sau: - Một `str`: Đường dẫn tuyệt đối đến tệp hình ảnh (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp ảnh (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp ảnh so với tệp lưu trữ. - `bytes`: Các byte của tệp hình ảnh. Điều này hữu ích cho các tệp parquet hoặc webdataset có nhúng các tệp ảnh. - Một `np.ndarray`: mảng NumPy đại diện cho một hình ảnh. - Một `PIL.Image.Image`: đối tượng ảnh PIL. Output: Dữ liệu đầu ra của Image được xuất dưới dạng các đối tượng `PIL.Image.Image`. Ví dụ: ```py >>> from datasets import load_dataset, Image >>> ds = load_dataset("AI-Lab-Makerere/beans", split="train") >>> ds.features["image"] Image(decode=True, id=None) >>> ds[0]["image"] >>> ds = ds.cast_column('image', Image(decode=False)) {'bytes': None, 'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/healthy/healthy_train.85.jpg'} ``` #### cast_storage[[datasets.Image.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L216) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Image arrow, đó là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ Image của arrow. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow Image là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.large_string()` - phải chứa dữ liệu "path" (sẽ được chuyển đổi sang chuỗi nếu có thể) - `pa.binary()` - phải chứa các byte của hình ảnh - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng - `pa.list(*)` - phải chứa dữ liệu mảng ảnh #### decode_example[[datasets.Image.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L139) **Tham số:** value (`str` hoặc `dict`) : Một chuỗi chứa đường dẫn tệp ảnh tuyệt đối, hoặc một từ điển có các khóa: - `path`: Chuỗi chứa đường dẫn tệp ảnh tuyệt đối hoặc tương đối. - `bytes`: Các byte của tệp ảnh. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp ảnh từ các kho riêng trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`). **Trả về:** `PIL.Image.Image` Giải mã tệp hình ảnh mẫu thành dữ liệu hình ảnh. #### embed_storage[[datasets.Image.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L278) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nhúng dữ liệu tệp cục bộ vào mảng hay không remote_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp từ xa vào mảng hay không. Ví dụ: các tệp có đường dẫn bắt đầu bằng hf:// hoặc https:// **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Image arrow, đó là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Nhúng các tệp hình ảnh vào mảng Arrow. #### encode_example[[datasets.Image.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L98) **Tham số:** value (`str`, `np.ndarray`, `PIL.Image.Image` hoặc `dict`) : Dữ liệu được truyền vào làm đầu vào cho tính năng Image. **Trả về:** `dict` với các trường "path" và "bytes" Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.Image.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L203) Nếu ở trạng thái có thể giải mã, trả về chính đặc trưng, ngược lại thì dẹt đặc trưng thành một từ điển. ### Video[[datasets.Video]] #### datasets.Video[[datasets.Video]] ```python datasets.Video(decode: bool = True, stream_index: typing.Optional[int] = None, dimension_order: typing.Literal['NCHW', 'NHWC'] = 'NCHW', num_ffmpeg_threads: int = 1, device: typing.Union[str, ForwardRef('torch.device'), NoneType] = 'cpu', seek_mode: typing.Literal['exact', 'approximate'] = 'exact', id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L29) **Tham số:** decode (`bool`, mặc định là `True`) : Có giải mã dữ liệu video hay không. Nếu `False`, sẽ trả về từ điển cơ bản ở định dạng `{"path": video_path, "bytes": video_bytes}`. stream_index (`int`, *optional*) : Chỉ số streaming cần sử dụng từ tệp. Nếu là `None`, mặc định sẽ dùng chỉ số "tốt nhất". dimension_order (`str`, mặc định là `NCHW`) : Thứ tự các chiều của các khung hình đã giải mã. Trong đó N là kích thước lô, C là số kênh, H là chiều cao và W là chiều rộng của các khung hình. num_ffmpeg_threads (`int`, mặc định là `1`) : Số lượng luồng được sử dụng để giải mã video. (Khuyến nghị giữ giá trị này ở mức 1) device (`str` hoặc `torch.device`, mặc định là `cpu`) : Thiết bị được sử dụng để giải mã video. seek_mode (`str`, mặc định là `exact`) : Xác định việc truy cập khung hình sẽ là “exact” hay “approximate”. Chế độ Exact đảm bảo rằng yêu cầu khung hình i luôn trả về khung hình i, nhưng điều này đòi hỏi phải quét tệp ban đầu. Chế độ Approximate nhanh hơn vì tránh quét tệp, nhưng kém chính xác hơn vì sử dụng metadata của tệp để tính toán vị trí khả dĩ của i. Đọc thêm [tại đây](https://docs.pytorch.org/torchcodec/stable/generated_examples/approximate_mode.html#sphx-glr-generated-examples-approximate-mode-py) Video `Feature` để đọc dữ liệu video từ tệp video. Đầu vào: Tính năng Video chấp nhận các đầu vào sau: - Một `str`: Đường dẫn tuyệt đối đến tệp video (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp video (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp video trong kho dữ liệu. - `bytes`: Số byte của tệp video. Điều này hữu ích cho các tệp parquet hoặc webdataset có nhúng tệp video. - Một `torchcodec.decoders.VideoDecoder`: đối tượng trình giải mã video của torchcodec. Output: Dữ liệu đầu ra của Video được cung cấp dưới dạng các đối tượng `torchcodec.decoders.VideoDecoder`. Ví dụ: ```py >>> from datasets import Dataset, Video >>> ds = Dataset.from_dict({"video":["path/to/Screen Recording.mov"]}).cast_column("video", Video()) >>> ds.features["video"] Video(decode=True, id=None) >>> ds[0]["video"] >>> video = ds[0]["video"] >>> video.get_frames_in_range(0, 10) FrameBatch: data (shape): torch.Size([10, 3, 50, 66]) pts_seconds: tensor([0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333], dtype=torch.float64) duration_seconds: tensor([0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167], dtype=torch.float64) >>> ds.cast_column('video', Video(decode=False))[0]["video] {'bytes': None, 'path': 'path/to/Screen Recording.mov'} ``` #### cast_storage[[datasets.Video.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L242) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Video arrow, đó là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow Video. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow Video là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.binary()` - phải chứa các byte của video - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng - `pa.list(*)` - phải chứa dữ liệu mảng video #### decode_example[[datasets.Video.decode_example]] ```python decode_example(value: typing.Union[str, datasets.features.video.Example], token_per_repo_id: typing.Optional[dict[str, typing.Union[bool, str]]] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L153) **Tham số:** value (`str` hoặc `dict`) : Một chuỗi chứa đường dẫn tuyệt đối của tệp video, hoặc một từ điển có các khóa: - `path`: Chuỗi chứa đường dẫn tuyệt đối hoặc tương đối của tệp video. - `bytes`: Các byte của tệp video. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp video từ các kho riêng tư trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`). **Trả về:** `torchcodec.decoders.VideoDecoder` Giải mã tệp video mẫu thành dữ liệu video. #### embed_storage[[datasets.Video.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L294) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nhúng dữ liệu tệp cục bộ vào mảng hay không remote_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp từ xa vào mảng hay không. Ví dụ: các tệp có đường dẫn bắt đầu bằng hf:// hoặc https:// **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Video arrow, đó là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Nhúng các tệp hình ảnh vào mảng Arrow. #### encode_example[[datasets.Video.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L105) **Tham số:** value (`str`, `np.ndarray`, `bytes`, `bytearray`, `VideoDecoder` hoặc `dict`) : Dữ liệu được truyền vào làm đầu vào cho tính năng Video. **Trả về:** `dict` với các trường "path" và "bytes" Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.Video.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L229) Nếu ở trạng thái có thể giải mã, trả về chính đặc trưng, ngược lại thì dẹt đặc trưng thành một từ điển. ### Mesh[[datasets.Mesh]] #### datasets.Mesh[[datasets.Mesh]] ```python datasets.Mesh(decode: bool = True, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L23) **Tham số:** decode (`bool`, mặc định là `True`) : Có giải mã dữ liệu lưới hay không. Nếu `False`, sẽ trả về từ điển cơ bản ở định dạng `{"path": mesh_path, "bytes": mesh_bytes}`. Việc giải mã lưới sử dụng `trimesh` và hỗ trợ các tệp `.glb`, `.gltf`, `.ply` và `.stl`. Mesh `Feature` để đọc dữ liệu lưới 3D từ tệp. Đầu vào: Tính năng Mesh chấp nhận các đầu vào sau: - Một `str`: Đường dẫn tuyệt đối đến tệp lưới (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp lưới (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp mesh so với tệp lưu trữ. - `bytes`: Các byte của tệp lưới. Điều này hữu ích cho các tệp parquet hoặc webdataset có nhúng các tệp mesh. - Một `trimesh.Trimesh` hoặc `trimesh.Scene`: đối tượng lưới hoặc cảnh 3D. Output: Tính năng Mesh xuất dữ liệu dưới dạng các đối tượng `trimesh.Trimesh` hoặc `trimesh.Scene`. #### cast_storage[[datasets.Mesh.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L162) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray]`) : Mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Mesh arrow, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow của Mesh. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow của Mesh là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.large_string()` - phải chứa dữ liệu "path" (sẽ được chuyển đổi sang chuỗi nếu có thể) - `pa.binary()` - phải chứa các byte của lưới - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng #### decode_example[[datasets.Mesh.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L91) **Tham số:** value (`dict`) : Một từ điển với các khóa: - `path`: Chuỗi chứa đường dẫn tệp mesh tuyệt đối hoặc tương đối. - `bytes`: Các byte của tệp mesh. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp mesh từ các kho riêng tư trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`). **Trả về:** `trimesh.Trimesh` hoặc `trimesh.Scene` Giải mã tệp lưới mẫu. #### embed_storage[[datasets.Mesh.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L215) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp cục bộ vào mảng hay không. remote_files (`bool`, mặc định là `True`) : Xác định có nhúng dữ liệu tệp từ xa vào mảng hay không. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Mesh arrow, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Nhúng các tệp mesh vào mảng Arrow. #### encode_example[[datasets.Mesh.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L57) **Tham số:** value (`str`, `bytes`, `dict`, `trimesh.Trimesh`, hoặc `trimesh.Scene`) : Dữ liệu được truyền vào làm đầu vào cho tính năng Mesh. **Trả về:** `dict` với các trường "path" và "bytes" Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.Mesh.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L149) Nếu ở trạng thái có thể giải mã, trả về chính đặc trưng, ngược lại thì dẹt đặc trưng thành một từ điển. ### Json[[datasets.Json]] #### datasets.Json[[datasets.Json]] ```python datasets.Json(decode: bool = True, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1250) Loại đặc trưng cho các đối tượng JSON. Bên trong, các đối tượng được lưu trữ dưới dạng chuỗi mã hóa JSON. Ví dụ: ```py >>> from datasets import Features, Json >>> features = Features({'json': Json()}) >>> features {'json': Json()} ``` ```py >>> from datasets import Dataset, Features, Json, List >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features) >>> # OR >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> ds[0] {'a': [{'b': 0}, {'c': 0}]} >>> def f(x): ... for y in x["a"]: ... y["d"] = "foo" ... return x >>> ds = ds.map(f) >>> ds.features >>> ds[0] {'a': [{'b': 0, 'd': 'foo'}, {'c': 0, 'd': 'foo'}]} ``` #### cast_storage[[datasets.Json.cast_storage]] ```python cast_storage(storage: Array) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1313) **Tham số:** storage (`Union[pa.StringArray, pa.IntegerArray]`) : mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.JsonArray` Array trong kiểu lưu trữ arrow `Json`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow `Json`. ### Pdf[[datasets.Pdf]] #### datasets.Pdf[[datasets.Pdf]] ```python datasets.Pdf(decode: bool = True, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L31) **Tham số:** decode (`bool`, mặc định là `True`) : Có giải mã dữ liệu pdf hay không. Nếu `False`, sẽ trả về từ điển cơ bản ở định dạng `{"path": pdf_path, "bytes": pdf_bytes}`. **Thử nghiệm.** Tính năng `Feature` của Pdf để đọc tài liệu pdf từ tệp pdf. Đầu vào: Tính năng Pdf chấp nhận các đầu vào sau: - Một `str`: Đường dẫn tuyệt đối đến tệp pdf (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp pdf (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp pdf trong kho dữ liệu. - `bytes`: Các byte của tệp pdf. Điều này hữu ích cho các tệp đã lưu trữ với truy cập tuần tự. - Một `pdfplumber.pdf.PDF`: đối tượng pdf của pdfplumber. Ví dụ: ```py >>> from datasets import Dataset, Pdf >>> ds = Dataset.from_dict({"pdf": ["path/to/pdf/file.pdf"]}).cast_column("pdf", Pdf()) >>> ds.features["pdf"] Pdf(decode=True, id=None) >>> ds[0]["pdf"] >>> ds = ds.cast_column("pdf", Pdf(decode=False)) >>> ds[0]["pdf"] {'bytes': None, 'path': 'path/to/pdf/file.pdf'} ``` #### cast_storage[[datasets.Pdf.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L183) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Pdf arrow, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow của Pdf. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow của Pdf là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.binary()` - phải chứa các byte của hình ảnh - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng - `pa.list(*)` - phải chứa dữ liệu mảng pdf #### decode_example[[datasets.Pdf.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L113) **Tham số:** value (`str` hoặc `dict`) : Một chuỗi chứa đường dẫn tuyệt đối của tệp pdf, hoặc một từ điển có các khóa: - `path`: Chuỗi chứa đường dẫn tuyệt đối hoặc tương đối của tệp pdf. - `bytes`: Các byte của tệp pdf. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp pdf từ các kho riêng trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`). **Trả về:** `pdfplumber.pdf.PDF` Giải mã tệp pdf mẫu thành dữ liệu pdf. #### embed_storage[[datasets.Pdf.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L220) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nhúng dữ liệu tệp cục bộ vào mảng hay không remote_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp từ xa vào mảng hay không. Ví dụ: các tệp có đường dẫn bắt đầu bằng hf:// hoặc https:// **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của PDF, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Nhúng các tệp PDF vào mảng Arrow. #### encode_example[[datasets.Pdf.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L78) **Tham số:** value (`str`, `bytes`, `pdfplumber.pdf.PDF` hoặc `dict`) : Dữ liệu được truyền vào làm đầu vào cho tính năng Pdf. **Trả về:** `dict` với các trường "path" và "bytes" Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.Pdf.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L170) Nếu ở trạng thái có thể giải mã, trả về chính đặc trưng, ngược lại thì dẹt đặc trưng thành một từ điển. ### Nifti[[datasets.Nifti]] #### datasets.Nifti[[datasets.Nifti]] ```python datasets.Nifti(decode: bool = True, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L64) **Tham số:** decode (`bool`, mặc định là `True`) : Có giải mã dữ liệu NIfTI hay không. Nếu `False`, một chuỗi chứa các byte sẽ được trả về. `decode=False` không được hỗ trợ khi giải mã các ví dụ. **Thử nghiệm.** `Feature` Nifti để đọc các tệp hình ảnh thần kinh NIfTI. Input: Tính năng Nifti nhận đầu vào là: - Một `str`: Đường dẫn tuyệt đối đến tệp NIfTI (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp NIfTI (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp NIfTI trong kho dữ liệu. - `bytes`: Các byte của tệp NIfTI. Điều này hữu ích cho các tệp đã lưu trữ với truy cập tuần tự. - Một đối tượng ảnh `nibabel` (ví dụ: `nibabel.nifti1.Nifti1Image`). Ví dụ: ```py >>> from datasets import Dataset, Nifti >>> ds = Dataset.from_dict({"nifti": ["path/to/file.nii.gz"]}).cast_column("nifti", Nifti()) >>> ds.features["nifti"] Nifti(decode=True, id=None) >>> ds[0]["nifti"] >>> ds = ds.cast_column("nifti", Nifti(decode=False)) >>> ds[0]["nifti"] {'bytes': None, 'path': 'path/to/file.nii.gz'} ``` #### cast_storage[[datasets.Nifti.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.BinaryArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L298) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray, pa.BinaryArray]`) : mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ Nifti arrow, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow Nifti. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow Nifti là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.binary()` - phải chứa các byte NIfTI - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng #### decode_example[[datasets.Nifti.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L150) **Tham số:** value (`str` hoặc `dict`) : Một chuỗi chứa đường dẫn tuyệt đối của tệp NIfTI, hoặc một từ điển có các khóa: - `path`: Chuỗi chứa đường dẫn tuyệt đối hoặc tương đối của tệp NIfTI. - `bytes`: Các byte của tệp NIfTI. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp NIfTI từ các kho riêng tư trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`). **Trả về:** đối tượng `nibabel.Nifti1Image` Giải mã tệp NIfTI mẫu thành đối tượng ảnh nibabel. #### embed_storage[[datasets.Nifti.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L216) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nhúng dữ liệu tệp cục bộ vào mảng hay không remote_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp từ xa vào mảng hay không. Ví dụ: các tệp có đường dẫn bắt đầu bằng hf:// hoặc https:// **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của NifTI, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Nhúng các tệp NifTI vào mảng Arrow. #### encode_example[[datasets.Nifti.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L110) **Tham số:** value (`str`, `bytes`, `nibabel.Nifti1Image` hoặc `dict`) : Dữ liệu được truyền vào làm đầu vào cho tính năng Nifti. **Trả về:** `dict` với các trường "path" và "bytes" Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.Nifti.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L285) Nếu ở trạng thái có thể giải mã, trả về chính đặc trưng, ngược lại thì dẹt đặc trưng thành một từ điển. ### BioSequence[[datasets.BioSequence]] #### datasets.BioSequence[[datasets.BioSequence]] ```python datasets.BioSequence(format: str = 'fasta', decode: bool = True, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L44) **Tham số:** format (`str`, mặc định là `"fasta"`) : Tên của định dạng trình tự, theo cách hiểu của `Bio.SeqIO`. Các giá trị phổ biến là `"fasta"`, `"fastq"` và `"genbank"`. decode (`bool`, mặc định là `True`) : Xác định có giải mã dữ liệu chuỗi hay không. Nếu `False`, sẽ trả về từ điển cơ bản ở định dạng `{"path": path, "bytes": bytes}`. **Thử nghiệm.** `Feature` BioSequence để đọc các bản ghi trình tự sinh học từ tệp trình tự. Một tệp trình tự chứa một hoặc nhiều bản ghi về các gốc (residue) kèm theo định danh và chú giải của chúng. FASTA, FASTQ và GenBank có cùng cấu trúc ở cấp độ này, chỉ khác nhau ở trình phân tích (parser) được sử dụng, do đó `format` chọn trình phân tích chứ không phải kiểu dữ liệu. Đầu vào: Tính năng BioSequence chấp nhận các đầu vào sau: - Một `str`: Đường dẫn tuyệt đối đến tệp trình tự (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp trình tự (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp trình tự trong kho dữ liệu. - `bytes`: Các byte của tệp trình tự. Điều này hữu ích cho các tệp đã lưu trữ với truy cập tuần tự. - Một `Bio.SeqRecord.SeqRecord`: bản ghi trình tự biopython. Ví dụ: ```py >>> from datasets import Dataset, BioSequence >>> ds = Dataset.from_dict({"seq": ["path/to/sequences.fasta"]}).cast_column("seq", BioSequence()) >>> ds.features["seq"] BioSequence(format='fasta', decode=True) >>> ds[0]["seq"] SeqRecord(seq=Seq('ACGT'), id='seq1', name='seq1', description='seq1', dbxrefs=[]) >>> ds = ds.cast_column("seq", BioSequence(decode=False)) >>> ds[0]["seq"] {'bytes': None, 'path': 'path/to/sequences.fasta'} ``` #### cast_storage[[datasets.BioSequence.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L199) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray]`) : Mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của BioSequence, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow BioSequence. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow BioSequence là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.binary()` - phải chứa các byte của tệp - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng #### decode_example[[datasets.BioSequence.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L132) **Tham số:** value (`str` hoặc `dict`) : Một chuỗi chứa đường dẫn tệp tuyệt đối, hoặc một từ điển có các khóa: - `path`: Chuỗi chứa đường dẫn tệp tuyệt đối hoặc tương đối. - `bytes`: Các byte của tệp. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp từ các kho riêng trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`). **Trả về:** `Bio.SeqRecord.SeqRecord` Giải mã tệp trình tự mẫu thành một bản ghi biopython. Một tệp có thể chứa nhiều bản ghi; hàm này trả về bản ghi đầu tiên vì một dòng tương ứng với một bản ghi. Hãy sử dụng các trình tải chuỗi có sẵn để mở rộng tệp nhiều bản ghi thành một dòng cho mỗi bản ghi. #### embed_storage[[datasets.BioSequence.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L219) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp cục bộ vào mảng hay không. remote_files (`bool`, mặc định là `True`) : Xác định có nhúng dữ liệu tệp từ xa vào mảng hay không. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của BioSequence. Nhúng các tệp trình tự vào mảng Arrow. #### encode_example[[datasets.BioSequence.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L99) **Tham số:** value (`str`, `bytes`, `Bio.SeqRecord.SeqRecord` hoặc `dict`) : Dữ liệu được truyền vào làm đầu vào cho tính năng BioSequence. **Trả về:** `dict` với các trường "path" và "bytes" Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.BioSequence.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L186) Nếu ở trạng thái có thể giải mã, trả về chính đặc trưng, ngược lại thì dẹt đặc trưng thành một từ điển. ### BioStructure[[datasets.BioStructure]] #### datasets.BioStructure[[datasets.BioStructure]] ```python datasets.BioStructure(format: str = 'pdb', decode: bool = True, id: typing.Optional[str] = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L48) **Tham số:** format (`str`, mặc định là `"pdb"`) : Định dạng cấu trúc, là `"pdb"` hoặc `"mmcif"`. decode (`bool`, mặc định là `True`) : Có giải mã dữ liệu cấu trúc hay không. Nếu `False`, sẽ trả về từ điển cơ bản ở định dạng `{"path": path, "bytes": bytes}`. **Thử nghiệm.** Tính năng `Feature` của BioStructure để đọc các cấu trúc đại phân tử từ tệp cấu trúc. Tệp cấu trúc chứa các tọa độ ba chiều của các nguyên tử trong một phân tử, được nhóm thành các chuỗi và các phần dư. PDB và mmCIF mô tả cùng các đối tượng và chỉ khác nhau ở trình phân tích được sử dụng, do đó `format` chọn trình phân tích chứ không phải kiểu dữ liệu. Đầu vào: Tính năng BioStructure chấp nhận các đầu vào sau: - Một `str`: Đường dẫn tuyệt đối đến tệp cấu trúc (tức là cho phép truy cập ngẫu nhiên). - Một `pathlib.Path`: đường dẫn đến tệp cấu trúc (tức là cho phép truy cập ngẫu nhiên). - Một `dict` với các khóa: - `path`: Chuỗi chứa đường dẫn tương đối của tệp cấu trúc trong kho dữ liệu. - `bytes`: Các byte của tệp cấu trúc. Điều này hữu ích cho các tệp đã lưu trữ với truy cập tuần tự. - Một `Bio.PDB.Structure.Structure`: cấu trúc biopython. Ví dụ: ```py >>> from datasets import Dataset, BioStructure >>> ds = Dataset.from_dict({"st": ["path/to/1abc.pdb"]}).cast_column("st", BioStructure()) >>> ds.features["st"] BioStructure(format='pdb', decode=True) >>> ds[0]["st"] >>> ds = ds.cast_column("st", BioStructure(decode=False)) >>> ds[0]["st"] {'bytes': None, 'path': 'path/to/1abc.pdb'} ``` #### cast_storage[[datasets.BioStructure.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L204) **Tham số:** storage (`Union[pa.StringArray, pa.StructArray]`) : Mảng PyArrow cần chuyển đổi kiểu. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của BioStructure, cụ thể là `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Đổ (cast) một mảng Arrow sang kiểu lưu trữ arrow của BioStructure. Các kiểu Arrow có thể chuyển đổi sang kiểu lưu trữ pyarrow của BioStructure là: - `pa.string()` - phải chứa dữ liệu "path" - `pa.binary()` - phải chứa các byte của tệp - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - thứ tự không quan trọng #### decode_example[[datasets.BioStructure.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L138) **Tham số:** value (`str` hoặc `dict`) : Một chuỗi chứa đường dẫn tệp tuyệt đối, hoặc một từ điển có các khóa: - `path`: Chuỗi chứa đường dẫn tệp tuyệt đối hoặc tương đối. - `bytes`: Các byte của tệp. token_per_repo_id (`dict`, *tùy chọn*) : Để truy cập và giải mã các tệp từ các kho riêng trên Hub, bạn có thể truyền một từ điển repo_id (`str`) -> token (`bool` hoặc `str`). **Trả về:** `Bio.PDB.Structure.Structure` Giải mã tệp cấu trúc ví dụ thành một cấu trúc biopython. #### embed_storage[[datasets.BioStructure.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L224) **Tham số:** storage (`pa.StructArray`) : mảng PyArrow để nhúng. token_per_repo_id (`dict`, tùy chọn) : Từ điển repo_id -> token để lấy các byte tệp. local_files (`bool`, mặc định là `True`) : Có nên nhúng dữ liệu tệp cục bộ vào mảng hay không. remote_files (`bool`, mặc định là `True`) : Xác định có nhúng dữ liệu tệp từ xa vào mảng hay không. **Trả về:** `pa.StructArray` Array trong kiểu lưu trữ arrow của BioStructure. Nhúng các tệp cấu trúc vào mảng Arrow. #### encode_example[[datasets.BioStructure.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')]) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L105) **Tham số:** value (`str`, `bytes`, `Bio.PDB.Structure.Structure` hoặc `dict`) : Dữ liệu được truyền vào làm đầu vào cho tính năng BioStructure. **Trả về:** `dict` với các trường "path" và "bytes" Mã hóa ví dụ thành định dạng cho Arrow. #### flatten[[datasets.BioStructure.flatten]] ```python flatten() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L191) Nếu ở trạng thái có thể giải mã, trả về chính đặc trưng, ngược lại thì dẹt đặc trưng thành một từ điển. ## Hệ thống tệp[[datasets.filesystems.is_remote_filesystem]] #### datasets.filesystems.is_remote_filesystem[[datasets.filesystems.is_remote_filesystem]] ```python datasets.filesystems.is_remote_filesystem(fs: AbstractFileSystem) ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/filesystems/__init__.py#L33) **Tham số:** fs (`fsspec.spec.AbstractFileSystem`) : Một lớp siêu trừu tượng cho các hệ thống tệp theo phong cách Python, ví dụ `fsspec.filesystem('file')` hoặc `s3fs.S3FileSystem`. Kiểm tra xem `fs` có phải là hệ thống tệp từ xa hay không. ## Dấu vân tay[[datasets.fingerprint.Hasher]] #### datasets.fingerprint.Hasher[[datasets.fingerprint.Hasher]] ```python datasets.fingerprint.Hasher() ``` [Nguồn](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L196) Hasher nhận các đối tượng python làm đầu vào.