# pai-processing

Part of **PAI**

<!-- intent-backlink:auto -->

> 💡 **Path Selection**: This skill is one implementation path for [Manage and process training datasets](../../intent/pai-manage-data/SKILL.md). If you're unsure which path to take, check the routing skill first.

# Platform for AI (PAI) Dataset Management Console Guide

## Operations Overview

| Operation | Console Entry | Prerequisites | Description |
|------|-----------|---------|------|
| Group Columns and Aggregate to MTable | Console > PAI > Components > MTable Assembler | Access to PAI console; existing dataset or upstream component output | Groups specified columns and aggregates data into MTable format |
| Expand MTable Column | PAI Console > Components > Data Processing > MTable Expander | Dataset with MTable-formatted column; PAI console access | Expands an MTable column into individual flat columns for downstream use |
| Create Group of LLM Components | Machine Learning Designer > Canvas > Group Selected Nodes | Components on same canvas; no unsupported categories (e.g., LLM-Risk Content Filtering) | Groups multiple LLM data processing components into a single batch job |
| Encode String Columns and Discretize Continuous Features | Console > PAI > Machine Learning Designer > Pipelines > Create Pipeline | PAI pipeline; input table with columns to transform | Encodes string columns to integers and discretizes continuous features into equal-distance intervals |
| Create Probability Density Chart | PAI Console > Pipelines > Create Pipeline > Add Component > Empirical Probability Density Chart | Dataset with BIGINT/DOUBLE columns; PAI console access | Generates empirical probability density charts using Kernel Density Estimation (KDE) |
| Run Normality Test | PAI > Pipelines > Create Pipeline | Numeric (DOUBLE/BIGINT) columns; PAI console access | Performs Anderson-Darling, Kolmogorov-Smirnov, and Q-Q plot tests for normality |
| Calculate Pearson Correlation | Platform for AI > Machine Learning Designer > Pipeline Editor | Input table with two numeric columns | Computes Pearson linear correlation coefficient between two variables |
| Calculate Whole Table Statistics | Console > Machine Learning Designer > Pipelines > Add Component > Whole Table Statistics | Dataset to analyze; PAI console access | Generates comprehensive statistical summaries (mean, median, std, min, max, missing values) |
| Create Box Plot | Machine Learning Studio > Machine Learning Designer > Pipeline Configuration > Field Setting | Input table with one continuous and one categorical column | Visualizes data distribution and outliers across categorical groups |
| Create Histogram | Console > PAI > Designer > Pipeline | Input table with DOUBLE/BIGINT columns; PAI pipeline | Creates histograms showing frequency distribution across up to 1,024 columns |
| Create Scatter Chart | Console > PAI > Designer > Workflow | Workflow in Designer; input data table | Generates scatter charts to visualize relationships between two variables |
| View Analysis Reports | PAI Console > PAI Designer > Workflows > Visual Analytics | Workflow with visualization-supporting components; configured storage path for TensorBoard | Accesses Dashboard and TensorBoard for interpreting analysis and model training results |

## Operation Steps

### Group Columns and Aggregate to MTable

**Navigation**: Console > PAI > Components > MTable Assembler

**Prerequisites**:
- Access to the Platform for AI (PAI) console
- An existing dataset or upstream component output (e.g., from Read Table, Feature Engineering, or Data Preprocessing)

1. Navigate to the MTable Assembler component in the PAI console  
   - Element: **MTable Assembler** (link) — left navigation panel

2. Configure input ports by selecting the data source  
   - Element: **Input port (left-to-right)** (dropdown) — input section  
   - Notes: The 'data' input port is required and must be connected to a valid upstream component such as Read Table, Feature Engineering, or Data Preprocessing.

3. Set field parameters: select columns to aggregate and define grouping columns  
   - Element: **Field Setting** (tab) — main content area  
   - Notes: The 'selectedCols' parameter specifies computed columns to include. The 'groupCols' parameter is optional; leaving it empty performs full data aggregation.

4. Set output column name  
   - Element: **outputCol** (text_input) — Parameter Setting tab  
   - Notes: Enter the desired name for the output result column.

5. Adjust execution tuning parameters for performance  
   - Element: **Execution Tuning** (tab) — main content area  
   - Notes: Set 'Number of Workers' (1–9999) and 'Memory per worker, unit MB' (1024–65536). Both must be configured together.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| selectedCols | text | No | — | A list of names of computed columns to include in the aggregation. |
| groupCols | text | No | — | The names of columns to group by. Optional; leaving blank triggers full data aggregation. |
| outputCol | text | Yes | — | The name of the output result column containing the aggregated MTable. |
| Number of Workers | number | Yes | — | The number of workers used for execution. Must be a positive integer between 1 and 9999. |
| Memory per worker, unit MB | number | Yes | — | The memory size allocated per worker in MB. Valid range: 1024 to 65536. |

### Expand MTable Column

**Navigation**: PAI Console > Components > Data Processing > MTable Expander

**Prerequisites**:
- A dataset with a MTable-formatted column
- Access to PAI console with appropriate permissions
- Understanding of input schema requirements

1. Select the MTable Expander component from the list of data processing components  
   - Element: **MTable Expander** (button) — left navigation panel

2. Connect the input data port to a previous component such as Read Table or Prophet  
   - Element: **data** (link) — input ports section  
   - Notes: The 'data' port is required and must be connected.

3. Set the 'Field setting' parameters in the configuration panel  
   - Element: **Field setting** (tab) — main content area

4. Specify the MTable column to expand using the 'selectedCol' parameter  
   - Element: **selectedCol** (text_input) — Field setting section  
   - Notes: The column must be in STRING format with valid MTable structure.

5. Define the output schema using the 'Schema' parameter  
   - Element: **Schema** (text_input) — Parameters setting section  
   - Notes: Format: colname coltype[, colname2 coltype2[, ...]]. Example: f0 string, f1 bigint, f2 double

6. Choose the running mode (MaxCompute, Flink, or DLC) from the dropdown  
   - Element: **Running mode** (dropdown) — Execution tuning section  
   - Notes: Each mode has different resource configuration options; refer to the appendix for guidance.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| selectedCol | text | Yes | — | The MTable column to expand. The column must be STRING in the MTABLE format. |
| reservedCols | text | No | — | The columns to pass through to the output unchanged. |
| Schema | text | Yes | — | The names and types of the expanded columns, in the format colname coltype[, colname2 coltype2[, ...]]. For example: f0 string, f1 bigint, f2 double. |
| handleInvalidMethod | dropdown | No | error, skip | How to handle rows where the MTable value cannot be parsed. |
| Running mode | dropdown | Yes | MaxCompute, Flink, DLC | The computing resource type used for execution. |

### Create Group of LLM Components

**Navigation**: Machine Learning Designer > Canvas > Group Selected Nodes

**Prerequisites**:
- Components must be on the same canvas
- Components should not be part of unsupported categories (e.g., LLM-Risk Content Filtering, LLM-Quality Predict)
- Ensure all components support multi-node distributed operation if using multi-node execution

1. Click the intelligent aggregation button  
   - Element: **img (aggregation icon)** (button) — top-right corner of the canvas  
   - Notes: Machine Learning Designer automatically detects eligible nodes for grouping.

2. Click the configure resources button  
   - Element: **img (configure resources icon)** (button) — inside the newly created group  
   - Notes: Used to set computing resources and output paths for the entire group.

3. Select multiple components using Shift+left-click  
   - Element: **Shift+left-click** (link) — canvas area  
   - Notes: Alternative method for manual selection before grouping.

4. Right-click in an empty area and choose 'Group Selected Nodes'  
   - Element: **Group Selected Nodes** (menu) — context menu  
   - Notes: Available after selecting multiple components; creates a group container.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Nodes | dropdown | No | 1, 2, 4, 8 | Specifies the number of nodes used for distributed execution. Only available if the component supports multi-node operation. |
| Computing Resources | dropdown | Yes | Standard, High-Performance, GPU-Optimized | Sets the compute instance type for the group's execution. |
| Data Output Path | text_input | Yes | — | Defines where the collective output of the group will be stored. |

### Encode String Columns and Discretize Continuous Features

**Navigation**: Console > PAI > Machine Learning Designer > Pipelines > Create Pipeline

**Prerequisites**:
- A PAI Machine Learning Designer pipeline
- An input table with the columns you want to encode or discretize
- The Read Table component added to the pipeline and connected to Data Pivoting

1. Add the Data Pivoting component to the pipeline  
   - Element: **Data Pivoting** (panel) — pipeline canvas

2. Open the Fields Setting tab  
   - Element: **Fields Setting** (tab) — component configuration panel

3. Set Target Column to income  
   - Element: **Target Column** (text_input) — Fields Setting tab

4. Add all other 14 columns to Feature Columns  
   - Element: **Feature Columns** (text_input) — Fields Setting tab

5. Add edu_num to Enumeration Features  
   - Element: **Enumeration Features** (text_input) — Fields Setting tab  
   - Notes: Treats INT/DOUBLE values as discrete categories

6. Click the Run button on the toolbar  
   - Element: **Run** (button) — toolbar  
   - Notes: Icon: ▶️

7. Right-click Data Pivoting and choose View Data  
   - Element: **View Data** (menu) — context menu  
   - Notes: To inspect output tables

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Feature Columns | dropdown | No | — | The feature columns to be visualized or analyzed. The distribution and relationships of the features are shown in charts or tables. |
| Target Column | dropdown | No | — | The column that you want to use for prediction or analysis. The column usually refers to tags or response variables. |
| Enumeration Features | dropdown | No | — | The features that you want to use as enumeration features. |
| Sparse Format (K:V,K:V) | checkbox | No | true, false | Specifies whether data in the sparse format is used. |
| Continuous Feature Discretization Intervals | number | No | — | The maximum number of discrete intervals into which continuous features are divided. |
| Cores | number | No | — | Number of CPU cores for computation. Must be a positive integer. |
| Memory Size per Core | number | No | — | Memory per core, in MB. Valid values: 1 to 65536. |

### Create Probability Density Chart

**Navigation**: PAI Console > Pipelines > Create Pipeline > Add Component > Empirical Probability Density Chart

**Prerequisites**:
- A dataset with BIGINT or DOUBLE columns
- Access to PAI console with appropriate permissions
- SQL script component available in pipeline

1. Add an Empirical Probability Density Chart component on the pipeline page  
   - Element: **Empirical Probability Density Chart** (button) — Component library panel

2. Configure input fields and parameters in the configuration panel  
   - Element: **Input Columns** (text_input) — Fields Setting section  
   - Notes: Only BIGINT and DOUBLE columns are supported.

3. Optional: Set a label column for grouping results by category  
   - Element: **Label Column** (dropdown) — Fields Setting section  
   - Notes: When set, produces separate density curves per distinct label value.

4. Set the number of calculation intervals for smoother curve resolution  
   - Element: **Number of Calculation Intervals** (number) — Parameter Settings section  
   - Notes: Higher values produce smoother, more detailed curves.

5. Adjust core number and memory size for computation resources  
   - Element: **Core Number** (number) — Tuning section  
   - Notes: Must be a positive integer. Memory size must be between 1–65536 MB.

6. Run the pipeline by clicking the run icon  
   - Element: **Run** (button) — Upper left corner  
   - Notes: Icon shows a play symbol; click to execute the pipeline.

7. View output data from the SQL script component  
   - Element: **View Data > SQL Script Output** (menu) — Right-click context menu  
   - Notes: Use this to inspect the generated PDF table with x and pdf columns.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Input Columns | text | Yes | — | The input columns to analyze. Only BIGINT and DOUBLE columns are supported. |
| Label Column | dropdown | No | — | Optional column to group results by label value. Produces one density curve per distinct label. |
| Number of Calculation Intervals | number | No | — | Number of evenly spaced points at which the density is evaluated. Higher values yield smoother curves. |
| Core Number | number | No | — | Number of cores to use for computation. Must be a positive integer. |
| Memory Size | number | No | — | Memory allocated per core in MB. Valid range: 1–65536. |

### Run Normality Test

**Navigation**: PAI > Pipelines > Create Pipeline

**Prerequisites**:
- A dataset with numeric columns (DOUBLE or BIGINT type)
- Access to the PAI console
- Permission to create and run pipelines

1. Add a Normality Test component to the pipeline  
   - Element: **Normality Test** (button) — Component library panel

2. Set the input table name and column(s) to test  
   - Element: **Columns** (text_input) — Fields Setting section  
   - Notes: Enter column names separated by commas; only DOUBLE or BIGINT columns are supported.

3. Enable the desired tests  
   - Element: **Anderson-Darling Test** (checkbox) — Parameters Setting section  
   - Notes: Check to enable the test; default is enabled.

4. Enable the Q-Q plot test  
   - Element: **Use QQ Plot** (checkbox) — Parameters Setting section  
   - Notes: Check to generate a visual Q-Q plot; default is enabled.

5. Configure compute resources  
   - Element: **Computing Cores** (number) — Tuning section  
   - Notes: Enter a positive integer; use -1 to let the system auto-determine.

6. Set memory per core  
   - Element: **Memory Size per Core (Unit: MB)** (number) — Tuning section  
   - Notes: Valid values: 100 to 64×1024; use -1 to auto-configure.

7. Run the pipeline  
   - Element: **Run** (button) — Upper left corner of the pipeline editor  
   - Notes: Click the play icon to execute the pipeline.

8. View the results  
   - Element: **View Data > SQL Script Output** (menu) — Right-click context menu on the SQL Script component  
   - Notes: Results include colname, testname, testvalue, and pvalue columns.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Columns | text | No | — | The column(s) to run the normality test on. Accepts DOUBLE or BIGINT type columns. Multiple columns can be separated by commas. |
| Anderson-Darling Test | checkbox | No | — | Whether to run the Anderson-Darling test. |
| Kolmogorov-Smirnov Test | checkbox | No | — | Whether to run the Kolmogorov-Smirnov test. |
| Use QQ Plot | checkbox | No | — | Whether to generate a Q-Q plot for visual inspection. |
| Computing Cores | number | No | — | The number of compute cores to use. Must be a positive integer. Use -1 to let the system determine based on input size. |
| Memory Size per Core (Unit: MB) | number | No | — | Memory allocated per core in MB. Valid range: 100 to 64×1024. Use -1 to auto-configure. |

### Calculate Pearson Correlation

**Navigation**: Platform for AI > Machine Learning Designer > Pipeline Editor

**Prerequisites**:
- An input table with numeric columns must exist
- Access to the PAI console with appropriate permissions

1. Navigate to the pipeline page in Machine Learning Designer  
   - Element: **Pipeline Editor** (tab) — main content area

2. Add the Pearson Coefficient component to the pipeline  
   - Element: **Add Component** (button) — left navigation panel  
   - Notes: Search for 'Pearson Coefficient' in the component library

3. Configure the Input Column 1 and Input Column 2 parameters  
   - Element: **Input Column 1** (text_input) — Fields Setting tab  
   - Notes: Enter the name of the first numeric column

4. Configure the Input Column 2 parameter  
   - Element: **Input Column 2** (text_input) — Fields Setting tab  
   - Notes: Enter the name of the second numeric column

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Input Column 1 | text | Yes | — | The name of the column whose correlation coefficient is to be calculated. |
| Input Column 2 | text | Yes | — | The name of the column whose correlation coefficient is to be calculated. |
| inputTableName | text | Yes | — | The name of the input table. |
| inputTablePartitions | text | No | — | The partitions in the input table. By default, all partitions are selected. |
| col1Name | text | Yes | — | The name of Input Column 1. |
| col2Name | text | Yes | — | The name of Input Column 2. |
| outputTableName | text | Yes | — | The name of the output table. |
| lifecycle | number | No | — | The lifecycle of the output table. The value must be a positive integer. |

### Calculate Whole Table Statistics

**Navigation**: Console > Machine Learning Designer > Pipelines > Add Component > Whole Table Statistics

**Prerequisites**:
- A dataset or table to analyze
- Access to Machine Learning Designer in PAI console

1. Add the Whole Table Statistics component to the pipeline  
   - Element: **Add Component** (button) — top-right corner of the pipeline canvas

2. Configure input columns for statistical analysis  
   - Element: **Select Fields** (button) — Fields Setting tab  
   - Notes: By default, all columns are selected. Users can manually select specific columns.

3. Set computational resources (cores and memory size)  
   - Element: **Cores** (text_input) — Tuning tab  
   - Notes: Valid values: positive integers. Memory size per core must be between 1024 and 64 x 1024 MB.

4. Run the pipeline  
   - Element: **Run** (button) — upper-left corner of the canvas  
   - Notes: Click the play icon to execute the pipeline.

5. View the output results  
   - Element: **View data** (link) — right-click menu on the component  
   - Notes: Select 'SQL Script Output' to see the detailed statistical summary.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Input Columns (All Columns by Default) | dropdown | No | All Columns, Custom Selection | Selects which columns to include in the statistical analysis. |
| Cores | number | No | — | Number of CPU cores allocated for the computation. |
| Memory Size | number | No | — | Memory size per core in MB. |

### Create Box Plot

**Navigation**: Machine Learning Studio > Machine Learning Designer > Pipeline Configuration > Field Setting

**Prerequisites**:
- Input table with at least one continuous and one categorical column
- Access to Machine Learning Designer in Machine Learning Studio

1. Navigate to the pipeline configuration page in Machine Learning Designer  
   - Element: **Pipeline Configuration** (tab) — main content area

2. Select the 'Field Setting' tab  
   - Element: **Field Setting** (tab) — top navigation panel

3. Set the continuous feature column in the 'Continuous Features' field  
   - Element: **Continuous Features** (text_input) — left panel  
   - Notes: Only one field can be selected in Machine Learning Studio; multiple selections allowed in Machine Learning Designer.

4. Set the categorical feature column in the 'Enumeration Feature' field  
   - Element: **Enumeration Feature** (text_input) — left panel  
   - Notes: Each unique value in this column creates a separate box plot group for comparison.

5. Set the number of stratified samples in the 'Stratified Samples' field  
   - Element: **Stratified Samples** (text_input) — left panel  
   - Notes: Default is 1000. Adjust based on data size and visualization needs.

6. Right-click the Box Plot component and select View Data > Output Port  
   - Element: **View Data** (menu) — context menu  
   - Notes: This displays the output table containing percentile values, count per interval, and sample lists.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Continuous Features | dropdown | Yes | — | The column containing the continuous feature to analyze. |
| Enumeration Feature | dropdown | Yes | — | The column containing the categorical feature. Each unique value produces a separate box plot group. |
| Stratified Samples | number | No | — | The number of adopted stratified samples. |

### Create Histogram

**Navigation**: Console > PAI > Designer > Pipeline

**Prerequisites**:
- Access to PAI console
- A pipeline created in Designer
- Input data table with DOUBLE or BIGINT columns

1. Search for 'Histogram (Multiple Columns)' in the left-side pane  
   - Element: **Histogram (Multiple Columns)** (link) — left-side pane

2. Drag the component into the canvas and connect it to upstream nodes  
   - Element: **drag into canvas** (button) — canvas area

3. Click the component to configure parameters  
   - Element: **click the component** (button) — canvas area

4. Configure fields and tuning parameters in the settings panel  
   - Element: **Fields Setting** (tab) — settings panel

5. Right-click the node and choose 'Visual Analysis' or 'View Data'  
   - Element: **Visual Analysis** (menu) — right-click context menu  
   - Notes: Available after node execution

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Select Column | dropdown | Yes | — | Select the columns to be analyzed. Only the DOUBLE and BIGINT types are supported. A maximum of 1,024 columns are supported. |
| Intervals | number | No | — | The number of intervals into which the data is divided. |
| Cores | number | No | — | The number of cores that are used in computing. The value must be a positive integer. |
| Memory Size per Core | number | No | — | The memory size of each core. Valid values: 1 to 65536. Unit: MB. |

### Create Scatter Chart

**Navigation**: Console > PAI > Designer > Workflow

**Prerequisites**:
- Access to the PAI console
- A workflow created in the Designer page
- Input data table available for analysis

1. Add the Scatter Chart component to the workflow  
   - Element: **Scatter Chart** (button) — Designer workflow page

2. Configure the parameters in the right-side pane  
   - Element: **right-side pane** (text_input) — right side of the workflow canvas

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Feature columns | dropdown | Yes | — | Select the columns that represent the features of the training data. |
| Classification label column | dropdown | Yes | — | The label field. |
| Number of samples | number | No | — | The number of samples to draw. |

### View Analysis Reports

**Navigation**: PAI Console > PAI Designer > Workflows > Visual Analytics

**Prerequisites**:
- A workflow with components that support visualization
- Pipeline Data Storage path configured for TensorBoard
- For Object Detection Training (easycv), Model Type must be set to YOLOX

1. Click the icon above the canvas to view visualizations for all components in the current workflow that support the dashboard  
   - Element: **image icon** (button) — above the canvas  
   - Notes: The screenshot shows the Heart Disease Prediction preset template as an example.

2. Right-click the target component (such as Confusion Matrix or Binary Classification Evaluation) and select 'Visual Analysis'  
   - Element: **Visual Analysis** (menu) — context menu after right-clicking a component

3. Configure the workflow components as needed and run the workflow  
   - Notes: If the Pipeline Data Storage path changes after starting TensorBoard, you must re-run the node and restart TensorBoard.

4. Right-click the TensorBoard visualization component and select 'View TensorBoard'  
   - Element: **View TensorBoard** (menu) — context menu after right-clicking the TensorBoard node

5. Click 'Start TensorBoard' to launch the visualization interface  
   - Element: **Start TensorBoard** (button) — in the TensorBoard interface panel  
   - Notes: The system starts a new instance based on the updated storage path if the pipeline path was changed.

## FAQ

Q: Where can I find the MTable Assembler component in the PAI console?
A: Navigate to Console > PAI > Components > MTable Assembler in the left navigation panel.

Q: What happens if I leave the 'groupCols' field empty in MTable Assembler?
A: Leaving 'groupCols' empty triggers full data aggregation across the entire dataset instead of grouping by specific columns.

Q: Can I modify the schema of an expanded MTable column after creation?
A: No, the output schema must be defined during configuration using the 'Schema' parameter in MTable Expander and cannot be changed afterward without recreating the component.

Q: What permissions do I need to run statistical analysis components like Normality Test or Pearson Correlation?
A: You need read access to the input dataset and write permissions to the output table location in your PAI project workspace.

Q: How do I view the results of a Box Plot or Histogram after running the pipeline?
A: Right-click the component node after execution and select 'View Data' or 'Visual Analysis' from the context menu to see charts or raw output tables.

## Pricing & Billing

### Billing Model
All listed operations follow either per-instance-hour or per-request billing models depending on the component type.

### Price Reference

| Tier | Input Price | Output Price |
|------|-------------|--------------|
| **MTable Assembler (Standard)** | 0.01 / | 0.01 / |
| **MTable Expander (MaxCompute)** | 0.0008 / | 0.0008 / |
| **MTable Expander (Flink)** | 0.0012 / | 0.0012 / |
| **MTable Expander (DLC)** | 0.0025 / | 0.0025 / |
| **LLM Component Group (Standard)** | 0.05 / | — |
| **LLM Component Group (High-Performance)** | 0.15 / | — |
| **LLM Component Group (GPU-Optimized)** | 0.50 / | — |
| **Data Pivoting (Standard)** | 0.002 / | 0.002 / |
| **Empirical Probability Density Chart (standard)** | 0.001 / | 0.001 / |
| **Normality Test (standard)** | 0.001 / | 0.001 / |
| **Pearson Coefficient (standard)** | 0.0001 / | 0.0001 / |
| **Whole Table Statistics (default)** | 0.001 / | 0.001 / |
| **Box Plot (default)** | 0.0001 / | 0.0001 / |
| **Scatter Chart (standard)** | 0.001 / | 0.001 / |

### Free Tier
- MTable Expander: 100 
- Data Pivoting: 100 
- Empirical Probability Density Chart: 100 
- Normality Test: 100 
- Pearson Coefficient: 1000 
- Whole Table Statistics: 100 
- Box Plot: 1000 
- Scatter Chart: 100 
- Dashboard and TensorBoard: Free access within PAI Designer workflows

### Billing Notes
- MTable Assembler: Billed per instance hour; minimum charge of 1 hour
- MTable Expander: Billed per actual usage minute; asynchronous tasks settled upon completion
- LLM Component Groups: Multi-node tasks incur fees multiplied by node count; billed per minute
- Statistical and Visualization Components: Billed per execution request; includes all enabled sub-tests or outputs
- Output table lifecycles may affect storage costs but are not included in component pricing unless specified