Step 4: Result Output

The model is trained and the data is cleaned — it's time to take your hard-earned results home! 🎁

The platform's export capabilities fall into four directions: model packages, clean data, analysis reports, and chart screenshots. They are described one by one below.

📦 Exit 1: Download the Online Model Package

Location: In the model list on the right, the Download Online Model Package button below the current model.

After clicking it, the system packages the entire model and its accompanying data into a single file:

File name: model_package_<model ID>.dimod
Format: .dimod (the platform's model package format, used for cross-machine migration/reuse)

💡 The difference between .dimod and Custom Download: .dimod "moves the whole package away" and is used to fully restore the analysis environment on another computer with the StarWay platform installed; the Custom Download described below exports a .joblib / .pkl that Python can load directly, for secondary development outside the platform.

⚠️ License restrictions

Model download is controlled by licensing. If you encounter the following messages, the current license does not support it:

Message	Cause
"Unauthorized or the license has expired, unable to download the model"	The license is invalid
"The current license does not support the model download feature, please upgrade your license"	The license has not enabled the download permission

License details can be viewed in Bottom Status Bar → About / License Information, which includes an item Download Permission: Allowed / Forbidden.

🎛️ Exit 2: Custom Download (Recommended)

Location: Model list on the right → Custom Download

This is the platform's most flexible export capability: check whatever you want to take with you.

Step 1: Choose the download format

Format	Description
`.joblib`	The recommended format in the Python ecosystem; highly efficient at serializing NumPy arrays
`.pkl`	The standard Python pickle format; the most universally compatible

Step 2: Check the download contents

The interface presents a JSON structure preview, intuitively showing which keys are in the model package and what type each one is:

json

{
  "model":        <sklearn model instance>,    // model file
  "x_scaler":     <StandardScaler>,            // X normalizer
  "y_scaler":     <StandardScaler>,            // Y normalizer
  "y_binarizer":  <LabelBinarizer>,            // Y classification encoder
  "train_data":   <pandas.DataFrame>,          // training set data
  "test_data":    <pandas.DataFrame>,          // test set data
  "full_data":    <pandas.DataFrame>,          // full dataset
  "model_info":   <dict>,                      // model metadata
  "data_config":  <dict>                       // data configuration
}

Option	Content	When you need it
`model`	The trained core model instance (PCA/PLS/OPLS…)	Required; without it you cannot predict
`x_scaler`	The normalizer for X	You must apply the same transformation first when predicting with new data
`y_scaler`	The normalizer for Y	Regression models need it to restore predicted values to their original scale
`y_binarizer`	The class encoder	Discriminant models only (PLS-DA / OPLS-DA)
`train_data`	Training set DataFrame	When you need to reproduce the training process
`test_data`	Test set DataFrame	When you need to reproduce the validation results
`full_data`	The complete dataset	When you need to deliver the model together with the data
`model_info`	Metadata such as model parameters, training metrics, and the optimal number of components	When you need to trace the model configuration
`data_config`	Column mapping configuration (which columns are X, which one is Y)	When you need to know the original column correspondence

💡 Smart linkage: the options adjust automatically with the model type ——
PCA models: y_scaler is not shown (there is no Y)
PLS / OPLS: y_scaler is shown, y_binarizer is not
PLS-DA / OPLS-DA: both are shown
By default, model, x_scaler, and model_info are checked (y_scaler is added automatically when there is a Y); this is the minimum usable combination.

Step 3: View the usage instructions

The right side of the dialog has complete built-in Python usage instructions and code examples, so there is no need to consult other documentation.

Install dependencies:

bash

pip install pandas scikit-learn joblib

Package structure: the downloaded .joblib / .pkl file is actually a Python dict, whose keys depend on what you checked.

Typical workflow:

python

import joblib

# 1. Load the model package
pkg = joblib.load("custom_model_package_xxx.joblib")

model     = pkg["model"]
x_scaler  = pkg["x_scaler"]
y_scaler  = pkg.get("y_scaler")
y_bin     = pkg.get("y_binarizer")

# 2. Data preprocessing (must be consistent with training)
X_new_scaled = x_scaler.transform(X_new)

# 3. Run the prediction
y_pred = model.predict(X_new_scaled)

# 4. Restore the results
#    Regression models: use y_scaler to restore the original scale
y_real = y_scaler.inverse_transform(y_pred)
#    Classification models: use y_binarizer to restore the class labels
labels = y_bin.inverse_transform(y_pred)

⚠️ Step 2 is the easiest place to make a mistake: new data must be transformed with the same x_scaler, otherwise the prediction results are completely unreliable.

🧹 Exit 3: Clean Data and Analysis Reports

Clean Data

The essence data left after your layers of screening and removal of outliers.

Format: CSV
Usage: Can be used directly in other analysis software, or as a "gold standard" dataset for the next round of modeling
How to get it: In the model list on the right, click the three small download icons Full / Tr / Te to export the full dataset / training set / test set respectively
File naming: {model_name}_{full_data|train_data|test_data}.csv

💡 Internally the platform stores data as Parquet, and converts it to CSV automatically on download (UTF-8 with BOM, so Excel opens it without garbled characters).
📌 Note the distinction: the Download column in the instance list exports the original Excel file you uploaded, not the cleaned data. To get the cleaning results, use the download buttons in the model list described above.

Analysis Report

The platform offers two kinds of reports for export, in different formats:

Report type	How it is generated	Supported export formats
AI Cleaning / Comparison / Chart Analysis Report	AI Analysis menu	Markdown + Word
Scenario Analysis / Configuration Diagram Analysis Report	Scenario menu	Markdown + Excel (multiple worksheets)

Markdown —— Good for archiving, pasting into a knowledge base / Wiki
Word —— Good for dropping straight into reporting materials, with no re-formatting needed
Excel —— Exports the tabular data in the report, which can be handed directly to the workshop to fill in

See: AI Capabilities Overview, Scenario Analysis and Configuration Diagram Analysis

📷 Exit 4: Chart and Canvas Screenshots

Method	Location	Output
Save a single chart	The camera 📷 at the top right of the chart	A high-resolution image of that chart, ready to insert into a PPT
Save canvas screenshot	The canvas toolbar	A screenshot of all the charts currently arranged on the canvas

💡 Save canvas screenshot is especially good for reporting: first drag the charts into the arrangement you want (you can use Auto Arrange to tidy them up in one click), then capture the whole thing.

🗂️ Complete Export Capability Comparison Table

What you want	Which exit to use	Output format
Reproduce the model on another computer with the platform	Download Online Model Package	`.dimod`
Use the model yourself in Python	Custom Download	`.joblib` / `.pkl`
Only the cleaned data	Model list → Full / Tr / Te download icons	`.csv`
The original file you uploaded	Instance list → Download	Original format (`.xlsx` / `.xls`)
A report you can show your boss	AI Analysis Report	`.md` / `.docx`
A form you can hand to the workshop to fill in	Scenario Analysis Report	`.md` / `.xlsx`
A chart you can insert into a PPT	Chart 📷 / Canvas screenshot	Image

⚠️ Notes

License restrictions: model download (both .dimod and Custom Download) requires the download permission to be enabled in the license
.joblib and .pkl — either one will do: .joblib is more efficient for models containing large arrays, while .pkl has broader compatibility
Mind the scikit-learn version: when loading a model package in Python, large differences in scikit-learn versions may cause load warnings, so it is recommended to keep it consistent with the generating environment
Don't forget to check x_scaler: downloading only model and leaving out x_scaler will make the prediction results completely wrong

AI Capabilities Overview —— The AI report system and export
Model Prediction (with Copy-Paste) —— Predict directly inside the platform without exporting files
Model Exploration and Parameter Optimization —— Use the model to work backward to the optimal process parameters

Step 4: Result Output ​

📦 Exit 1: Download the Online Model Package ​

⚠️ License restrictions ​

🎛️ Exit 2: Custom Download (Recommended) ​

Step 1: Choose the download format ​

Step 2: Check the download contents ​

Step 3: View the usage instructions ​

🧹 Exit 3: Clean Data and Analysis Reports ​

Clean Data ​

Analysis Report ​

📷 Exit 4: Chart and Canvas Screenshots ​

🗂️ Complete Export Capability Comparison Table ​

⚠️ Notes ​

🔗 Related Reading ​