Use Dataset.Tabular.from_delimited_files to prepare a checked public dataset

If an Azure Machine Learning notebook uses Dataset.Tabular.from_delimited_files, the useful publishing workflow is: load the source files, check the parsed records, and export a reviewed CSV. Creating a TabularDataset alone does not create a public data page.

This guide uses a synthetic three-record dataset. The expected result is a CSV with three columns, identifiers such as 001 preserved, and no extra row-index column.

Version note, October 2026: this method belongs to Azure Machine Learning’s Python SDK v1. Microsoft deprecated v1 on March 31, 2025, and its support ended June 30, 2026. Microsoft says existing workflows will continue to operate after that date, but may face security risks or breaking changes. Maintain the legacy example only where needed; use the current approach below for new Azure ML table-loading work. Microsoft’s SDK v1 notice

What the method does

Dataset.Tabular.from_delimited_files defines how to read delimited text, including CSV and TSV, into a TabularDataset. Supported sources include Azure ML datastore paths and public web URLs. The dataset references its source; to_pandas_dataframe() materializes the table into a pandas DataFrame—an in-memory table you can inspect and export. Microsoft’s dataset guide

For this example, save the following as release-sample.csv:

record_id,region,observations
001,North,12
002,South,8
003,West,0

Here, record_id is text, not a quantity. observations is a whole-number count, and zero means an observed count of zero—not missing data.

Load it in an existing SDK v1 workflow

This snippet assumes your notebook already has a configured datastore object and the sample file is stored there at release/release-sample.csv. It does not upload the local file or configure Azure credentials. Only materialize a dataset that fits your available memory.

from azureml.core import Dataset
from azureml.data import DataType

dataset = Dataset.Tabular.from_delimited_files(
    path=(datastore, "release/release-sample.csv"),
    separator=",",
    header=True,
    encoding="utf8",
    set_column_types={
        "record_id": DataType.to_string(),
        "region": DataType.to_string(),
        "observations": DataType.to_long(),
    },
)

df = dataset.to_pandas_dataframe()

The explicit identifier type prevents numeric inference from stripping leading zeros. These arguments and type overrides follow Microsoft’s factory reference.

Before applying the method to a real dataset, check these parsing choices:

Source condition	SDK v1 setting or check
Tab-separated file	Use separator="\t".
Quoted fields contain line breaks	Use support_multi_line=True.
Identifiers resemble numbers	Override those columns with DataType.to_string().
Several files are combined	Check that their headers and column meanings match. header=True assumes the same header in every file.
Empty fields need a documented meaning	The default empty_as_string=False loads them as nulls.

Two defaults deserve attention. Type inference examines only the first 200 rows, so later values can expose a misleading inferred type. Also, support_multi_line=False treats even quoted line breaks as record breaks, potentially creating extra rows with misaligned fields. Microsoft’s parameter documentation

If validation fails, check source access from the current compute environment. Setting validate=False skips the initial loading check; it does not repair permissions or malformed data. The reference also requires infer_column_types=False to disable validation. Validation parameters

For new work: use MLTable, not a renamed v1 call

The current table-loading option is mltable.from_delimited_files. Its arguments differ: it uses paths, delimiter, and dictionary-based type-inference settings. It can read local files directly. Its multiline setting also defaults to False, so use support_multi_line=True for quoted line breaks. MLTable API reference

Install the packages for the current approach using Microsoft’s installation guidance:

pip install -U mltable "azureml-dataprep[pandas]"

Then load the local sample:

import mltable

table = mltable.from_delimited_files(
    paths=[{"file": "./release-sample.csv"}],
    delimiter=",",
    header="all_files_same_headers",
    encoding="utf8",
    infer_column_types={
        "column_type_overrides": {
            "record_id": "string",
            "region": "string",
            "observations": "int",
        }
    },
)

df = table.to_pandas_dataframe()

MLTable is useful when you need a reusable loading blueprint. It is not mandatory for every CSV: Microsoft notes that Azure ML file/folder assets with your own parsing logic can be simpler for straightforward inputs. Microsoft’s current table guide

Check the records, then export the release copy

After either loading approach, run these checks for the synthetic sample:

assert list(df.columns) == ["record_id", "region", "observations"]
assert len(df) == 3
assert df["record_id"].is_unique
assert set(df["record_id"]) == {"001", "002", "003"}
assert df["observations"].notna().all()
assert (df["observations"] >= 0).all()
assert df["observations"].sum() == 20

print(df)
print(df.dtypes)

df.to_csv("public-release.csv", index=False, encoding="utf-8")

For real data, replace the sample expectations with independently known row counts, identifier rules, missing-value rules, and control totals.

index=False matters because pandas otherwise writes the DataFrame’s row index into the CSV. Missing values export as empty fields by default; ensure that matches your documented missing-value convention. pandas export documentation

Review public-release.csv before publishing. Remove sensitive records, credentials, internal storage paths, and fields you lack permission to disclose. Keep provenance, units, and missing-value definitions in a dataset reference sheet.

TablePage accepts CSV, TSV, XLSX, and XLS files and creates a public dataset page with a shareable link and filterable table. Upload only the reviewed release copy—not private training data. TablePage’s publishing overview

Before sharing the link, compare the published records with the release file: confirm the three sample rows, check that 001 remains intact, and verify that zero has not become a blank. A successful load is only the first check; the public table must preserve the meaning of the source.