EXAONE Tabular

POST /v1/tabular/classification

POST /v1/tabular/regression

Discover EXAONE Tabular, a tabular foundation model developed by LG AI Research. Designed for classification and regression tasks, EXAONE Tabular enables efficient predictions on structured data without dataset-specific model training.

Request information

Request Content-Type: multipart/form-data

Field	Type	Description	Required
`train_file`	file	The training CSV file	mandatory
`test_file`	file	The CSV file containing the rows to predict	mandatory
`mode`	string	Enter `default`	mandatory
`output_type`	string	Classification: `class` / `probability` (default: `"class"`) Regression: `point`(Point predictions) / `full`(a quantile-based predictive distribution)(default: "`point`")	mandatory
`target_columns`	array<string>	The name of the target column to predict (default: `"target"`) Only the first value is used, so enter a single value	mandatory

Response information

Classification

Field	Type	Description
`result_code`	number	http status code
`description`	string	Error details (null when result_code is 200)
`data.target_columns`	array<string>	A list of target column names
`data.classes`	array<array>string>>	The class labels for each target, classification only Derived from the task's labeled target values converted to strings. Listed in the same order as the class probabilities
`data.labels`	array<array<string>>	Returned for classification when `output_type="class"` The predicted labels, indexed as `[query row][target]`
`data.probabilities`	array<array<array<number>>>	Returned for classification when `output_type="probability"` The class probabilities, indexed as `[query row][target][class]`

Regression

Field	Type	Description
`result_code`	number	http status code
`description`	string	Error details (null when result_code is 200)
`data.target_columns`	array<string>	A list of target column names
`data.predictions`	array<array>number>>	The numeric point predictions for the query rows
`data.quantiles`	array<array<number>>	The predictive distribution for each target of the query rows
`data.quantile_levels`	array<array<number>>	The cumulative probability for each index in quantiles

Interpreting Predictions

For both classification and regression, results are returned only for the query rows in each task. Predictions for the training rows are not included.

task type	output type	description
Classification	class	The predicted class for each query row
Classification	probability	The probability of each class for each query row
Regression	point prediction	The numeric point prediction for each query row
Regression	distribution	The predictive distribution of the target value for each query row

For classification, only one of labels or probabilities is returned, depending on the requested output_type.

With a single target (currently the only supported option), the result sizes are as follows. For classification with output_type = "probability", probabilities are returned in the order listed in classes and rounded to six decimal places.

output_type	result field	length
`class`	`labels`	`(n_test_rows, 1)`
`probability`	`probabilities`	`(n_test_rows, 1, n_classes)`

The regression distribution output is different from the per-class probabilities returned for classification. For regression, output_type="point" returns point predictions, and output_type="full" returns a quantile-based predictive distribution.

output type	Per-Row Result	Shape
point prediction	One number per query row and target	With the target axis retained, a single target has shape `(n_test_rows, 1)`
distribution	One predictive distribution per query row and target	The data type and shape depend on how the distribution is represented, so a separate specification is required

output_type	result field	length
`point (default)`	`predictions`	`(n_test_rows, 1)`
`full`	`quantiles`	`(n_test_rows, 1, 999)`
`full`	`quantile_levels`	`(1, 999)`

quantiles: Represents the predictive distribution of each test_row as a set of values, as many as the length of quantile_levels.

quantile_levels: The cumulative probability (CDF) for each index in quantiles. In other words, quantile_levels[target][i] is the predicted probability that the target value is less than or equal to quantiles[row][target][i].

quantile_levels is defined as i/(N+1) for i = 1…N (for N = 999, this ranges from 0.001 to 0.999), so it can be derived from the size of the last axis of quantiles alone. It is included to keep the response self-contained: you don't need to hard-code the level values, and your code will keep working even if the number or distribution of quantiles changes in a future model checkpoint.

Usage: Find the index of the cumulative probability you need (for example, 0.05 or 0.95) in quantile_levels[0], then read quantiles[row][0] at the same index to get that quantile value for the row.

Request Example (Classification)

curl 'https://api.exaone.ai/v1/tabular/classification' \
  -H "Authorization: Bearer $EXAONE_API_KEY" \
  -F 'train_file=@classification_train.csv;type=text/csv' \
  -F 'test_file=@classification_test.csv;type=text/csv' \
  -F 'mode=default' \
  -F 'output_type=class' \
  -F 'target_columns=churn'

import requests

url = "https://api.exaone.ai/v1/tabular/classification"
headers = {
    "Authorization": f"Bearer {EXAONE_API_KEY}",
}
data = {
    "mode": "default",
    "output_type": "class",
    "target_columns": "churn",
}

with (
    open("classification_train.csv", "rb") as train_file,
    open("classification_test.csv", "rb") as test_file,
):
    files = {
        "train_file": ("classification_train.csv", train_file, "text/csv"),
        "test_file": ("classification_test.csv", test_file, "text/csv"),
    }
    response = requests.post(url=url, headers=headers, data=data, files=files)

print(response.text)

const fs = require('fs');

(async () => {
  const url = 'https://api.exaone.ai/v1/tabular/classification';
  const headers = {
    Authorization: `Bearer ${process.env.EXAONE_API_KEY}`,
  };

  const form = new FormData();
  form.append(
    'train_file',
    new Blob([fs.readFileSync('classification_train.csv')], { type: 'text/csv' }),
    'classification_train.csv',
  );
  form.append(
    'test_file',
    new Blob([fs.readFileSync('classification_test.csv')], { type: 'text/csv' }),
    'classification_test.csv',
  );
  form.append('mode', 'default');
  form.append('output_type', 'class');
  form.append('target_columns', 'churn');

  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: headers,
      body: form,
    });
    console.log(await response.text());
  } catch (error) {
    console.error('Error:', error);
  }
})();

Response Example (Classification)

{
  "result_code": 200,
  "description": null,
  "data": {
    "target_columns": ["churn"],
    "classes": [["no", "yes"]],
    "labels": [
      ["yes"],
      ["yes"],
      ["no"],
      ["no"],
      ["yes"],
      ["no"],
      ["yes"],
      ["no"],
      ["no"],
      ["yes"],
      ["yes"],
      ["no"]
    ],
    "probabilities": null
  }
}

Request Example (Regression)

curl 'https://api.exaone.ai/v1/tabular/regression' \
  -H "Authorization: Bearer $EXAONE_API_KEY" \
  -F 'train_file=@regression_train.csv;type=text/csv' \
  -F 'test_file=@regression_test.csv;type=text/csv' \
  -F 'mode=default' \
  -F 'output_type=point' \
  -F 'target_columns=price'

import requests

url = "https://api.exaone.ai/v1/tabular/regression"
headers = {
    "Authorization": f"Bearer {EXAONE_API_KEY}",
}
data = {
    "mode": "default",
    "output_type": "point",
    "target_columns": "price",
}

with (
    open("regression_train.csv", "rb") as train_file,
    open("regression_test.csv", "rb") as test_file,
):
    files = {
        "train_file": ("regression_train.csv", train_file, "text/csv"),
        "test_file": ("regression_test.csv", test_file, "text/csv"),
    }
    response = requests.post(url=url, headers=headers, data=data, files=files)

print(response.text)

const fs = require('fs');

(async () => {
  const url = 'https://api.exaone.ai/v1/tabular/regression';
  const headers = {
    Authorization: `Bearer ${process.env.EXAONE_API_KEY}`,
  };

  const form = new FormData();
  form.append(
    'train_file',
    new Blob([fs.readFileSync('regression_train.csv')], { type: 'text/csv' }),
    'regression_train.csv',
  );
  form.append(
    'test_file',
    new Blob([fs.readFileSync('regression_test.csv')], { type: 'text/csv' }),
    'regression_test.csv',
  );
  form.append('mode', 'default');
  form.append('output_type', 'point');
  form.append('target_columns', 'price');

  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: headers,
      body: form,
    });
    console.log(await response.text());
  } catch (error) {
    console.error('Error:', error);
  }
})();

Response Example (Regression)

{
  "result_code": 200,
  "description": null,
  "data": {
    "target_columns": ["price"],
    "predictions": [
      [240.70724487304688],
      [114.92210388183594],
      [263.53741455078125],
      [138.78909301757812],
      [242.1593475341797],
      [76.70890045166016],
      [160.2372589111328],
      [135.4267578125],
      [143.27110290527344],
      [191.79373168945312],
      [229.5113983154297],
      [130.65866088867188]
    ],
    "quantiles": null,
    "quantile_levels": null
  }
}