import { QBreadcrumbs, QBreadcrumbsEl } from './QBreadcrumbs-d508f268.js';
import { QSeparator } from './QSeparator-f2beec84.js';
import { QItem, QItemSection } from './QItem-1f9e6dcc.js';
import { QList } from './QList-5be5d7fb.js';
import { MarkdownViewer } from './MarkdownViewer-d011cacb.js';
import { Footer } from './Footer-f8b1d9cc.js';
import { _export_sfc } from './_plugin-vue_export-helper-e9a2c33e.js';
import { createElementBlock, createBaseVNode, createVNode, withCtx, resolveComponent, openBlock, createTextVNode, pushScopeId, popScopeId } from './__federation_expose_Modules-a9c6a6fc.js';

const content = `
#### **Machine Learning Pipeline in D2 System**

D2 currently offers pipeline support for two forecasting tasks:
- **Daily demand power forecasting:** involves predicting the expected electricity demand over a 24-hour period. It helps utility companies and grid operators optimize power generation, prevent outages, and ensure reliable energy delivery. 
- **Solar power generation forecasting:** involves forecasting the amount of electricity generated by solar PV systems. It helps optimize grid integration, manage variations in solar output, and maximize the utilization of renewable energy resources.

Despite being two distinct tasks, the two pipelines still share four common components:

![MarineGEO circle logo](/images/pipeline_components.png#5_steps_pipeline)

#### **Pipeline Components in Details**

In this section, we will describe in details about each components in the pipeline.

##### ***Retrieval of Training Job Metadata***

![MarineGEO circle logo](/images/pipeline_components_1.png#1st_steps_pipeline)

Retrieval of training job metadata including: 
- Kubeflow experiment name
- Kubeflow experiment ID
- Created date
- Training job configuration

##### ***Data Pre-processing***

![MarineGEO circle logo](/images/pipeline_components_2.png#2nd_steps_pipeline)

Data pre-processing helps enhance the quality, consistency, and suitability of the data for training deep learning models. It enables the models to learn from reliable information, improves convergence, and enhances their ability to make accurate predictions on real-world data.

This component includes several sub-tasks including:
  
###### **1. Data Loading**  
  
Depending on user preferences, the dataset can be sourced either from Amazon S3 or from the user's private dataset.
  

###### **2. Exploratory Data Analysis (EDA)**  
  
During this step, EDA process is divided into several steps with the purpose of improving the data quality and uncovering hidden characteristics and trends. These steps include:
- Data types checking: By checking data types, we can assure it matched with the expected data types.
- Data cleaning: In this step, we employ techniques to detect and handle unwanted characteristics within the dataset, such as duplicated entries, missing values, and outliers.
- Data visualization: By employing various types of visual representations, such as boxplot, correlation plots, or time series decomposition, we can identify hidden patterns and relationships between dependent and independent variables in time series data.  
  
###### **3. Data Splitting**  
  
In order to asses the model's performance objectively, avoid bias, and ensure its generalizability to unseen data, the dataset must be splitted into 3 subsets called: 
- Training set: The sample of data used to fit the model.
- Validation set: The sample of data used to provide an unbiased evaluation of a model fit on the training dataset while tuning model hyperparameters. 
- Testing set: The sample of data used to provide an unbiased evaluation of a final model fit on the training dataset.  

Users can set a specific ratio for splitting the dataset. 

###### **4. Feature Engineering**  
  
This step refers to the process of selecting, creating, and transforming input variables (features) from the time series data to improve the performance and predictive power of a forecasting model.  
  
When creating new features, various types of existing features can be considered, including:
- Lagged Variables: Creating lagged versions of the target variable or other relevant variables as input features.
- Rolling Statistics: Computing rolling statistics, such as moving averages, standard deviations, or other aggregations, over a specific window of time.
- Time-based Features: Incorporating features based on the time and date characteristics, such as day of the week, month, hour of the day, or holiday indicators.
- Domain-specific Features: Including domain-specific knowledge or features that are known to impact the time series being forecasted.  

As mentioned earlier, D2 supports two tasks, and the features used for each task are as follows:  
- Daily demand power forecasting:
    - Time-based Features* : minute, hour, weekday, holiday, month.
    - Lagged Variables.
    - Rolling Statistics: expanding window sum of daily power.
- Solar power generation forecasting:
    - Time-based Features* : minute, hour, weekday, holiday, month.
    - Lagged Variables.
    - Domain-specific Features: temperature, humidiy, wind degree.

> **(*)** To avoid discontinuity when transitioning between two periods of time, we utilize spline transformation for handling time-based features instead of using raw ordinal values. For example, when considering the hour of observed power consumption, the transition from 23 (p.m.) to 0 (a.m.) is treated as a continuous progression, equivalent to the transition from 22 (p.m.) to 23 (p.m.), rather than a sudden jump in distance when using the raw oridinal values. This approach ensures the accurate representation of time-related patterns in the data.  
  
###### **5. Data Normalizing**  
  
Data normalization, also known as feature scaling, is a process of transforming the numerical values of different features in a dataset to a consistent scale.
  
The purpose of this step is to  address issues related to the varying scales and units of different features, preventing certain features from dominating the learning process based solely on their larger magnitudes. It can improve the convergence of optimization algorithms and prevent biases in the model's learning. 
  
D2 suppports two options for data normalization:
- Min-Max Scaling: This technique rescales the data to a specific range, typically between 0 and 1. It subtracts the minimum value from each data point and divides it by the difference between the maximum and minimum values.
- Z-Score Standardization: Z-score standardization transforms the data to have a mean of 0 and a standard deviation of 1. It subtracts the mean from each data point and divides it by the standard deviation of the feature.

##### ***Model Building***

![MarineGEO circle logo](/images/pipeline_components_3.png#3rd_steps_pipeline)

This component is responsible for the modeling process and hyperparameter optimization.  
  
###### **Model Selection**
  
D2 utilizes the *Long Short-Term Memory (LSTM) network* as the main component for the forecasting task due to its proven capability in learning and retaining temporal patterns in data.

![MarineGEO circle logo](/images/model.png#model)

LSTM (Long Short-Term Memory) is indeed a type of recurrent neural network (RNN) that has been specifically designed to tackle the vanishing gradient problem often encountered in traditional RNNs. The critical aspect of LSTM lies in its cell design. Unlike standard RNN cells, LSTM cells incorporate a more complex structure that allows them to capture and retain long-term dependencies in sequential data. 
  
The details of LSTM cell is shown as the figure below:

![MarineGEO circle logo](/images/LSTM_cell.png)
  
To gain a deeper understanding of the working principles of RNNs and LSTM, we recommend exploring the excellent resource available at [here](https://colah.github.io/posts/2015-08-Understanding-LSTMs/). It will provide comprehensive insights into the functionality and architecture of these neural network models.
  
###### **Model Training**  
  
The training process for a deep neural network consists of multiple iterations, called *epochs*. For the first epoch, you start by assigning random initialization values for the parameters in the network. Then the process is as follows:

1. Features for data observations are submitted to the model. Generally, these observations are grouped into *batches* (often referred to as *mini-batches*).
2. The network applies its computations and passes the results between consecutive layers, propagating the information through the network. This process continues until the final layer generates a prediction based on the learned representations and transformations from the preceding layers. (This step is also referred as *forward-propagation*).
3. The prediction is compared to the actual known value, and the amount of variance between the predicted and true values (which we call the *loss*) is calculated.
4. Based on the results, revised values for every parameters are calculated to reduce the loss, and these adjustments are called *backpropagated* in the network layers.
5. The next epoch repeats the batch training forward pass with the revised weight and bias values, hopefully improving the accuracy of the model (by reducing the loss).

Upon reaching the final epoch of the training process, we obtain an optimized model that is well-suited for our specific task.
  
###### **Hyperparameters Optimization**

In deep learning models, in addition to the learnable parameters of the network, there exists another type of parameters known as *hyperparameters.*  
  
*Hyperparameters* are settings or configurations that are not learned directly from the data but rather set by the user before the training process. 
  
Examples of hyperparameters include:
- Learning rate
- Batch size
- Number of layers 
- Regularization parameters.
- ...

*Hyperparameter tuning* is the process of optimizing the hyperparameter values to maximize the predictive accuracy of the model. It plays a crucial role in achieving optimal model performance and improving the overall training process.
  
In the D2 system, we leverage [Katib](https://github.com/kubeflow/katib) as the framework for automating the tuning of hyperparameters.

To see more details about hyperparamtres optimization, please refer to the [Hypeprameters Optimization section.](/docs/components/hpo)

###### **Model Testing**  
  
Model testing is a crucial step in the machine learning process that assesses the performance and effectiveness of a trained model.

During this step, the trained model is fed with the test dataset acquired from the data splitting process. The model then generates predictions for the test samples, and these predictions are compared against the corresponding ground truth values. To assess the performance of the model, various metrics can be calculated, such as Mean Absolute Error (MAE), Mean Squared Error (MSE), or Mean Absolute Percentage Error (MAPE).

By evaluating the model on unseen data, testing provides an objective measure of its accuracy, generalization ability, and reliability. It helps detect overfitting, allows for model comparison and selection, aids decision-making, and facilitates iterative improvement.



##### ***Model Exporting***

![MarineGEO circle logo](/images/pipeline_components_4.png#4th_steps_pipeline)

Model exporting serves as the final component of the pipeline.

Once the modeling process is complete, the optimized models, metadata, and artifacts generated during the training process are stored in the system's storage. 

This ensures that the trained models are readily available and accessible by users to make predictions or perform inference using the trained models through the system's serving API endpoints.
`;

const pipelineComponents_vue_vue_type_style_index_0_scoped_f7867c81_lang = '';

const _sfc_main = {
  components: {
    MarkdownViewer,
    Footer
  },
  data() {
    return {
      value: content,
      slideItems: [{
        linkImage: '/src/assets/images/pipeline_components_1.png'
      }, {
        linkImage: '/src/assets/images/pipeline_components_2.png'
      }, {
        linkImage: '/src/assets/images/pipeline_components_3.png'
      }, {
        linkImage: '/src/assets/images/pipeline_components_4.png'
      }, {
        linkImage: '/src/assets/images/pipeline_components_5.png'
      }],
      slide: '0',
      activeMachineLearningPipelineinD2: true,
      activePipelineComponentinDetails: false,
      activeRetrievalTrainingJobMetadata: false,
      activeDataPreprocess: false,
      activeDataLoading: false,
      activeEDA: false,
      activeDataSplitting: false,
      activeFeatureEngineering: false,
      activeDataNormalizing: false,
      activeModelBuilding: false,
      activeModelSelection: false,
      activeModelTraining: false,
      activeHyperparametersOptimization: false,
      activeModelTesting: false,
      activeModelExporting: false
    };
  },
  methods: {
    setActive(section) {
      this.activeMachineLearningPipelineinD2 = false;
      this.activePipelineComponentinDetails = false;
      this.activeRetrievalTrainingJobMetadata = false;
      this.activeDataPreprocess = false;
      this.activeDataLoading = false;
      this.activeEDA = false;
      this.activeDataSplitting = false;
      this.activeFeatureEngineering = false;
      this.activeDataNormalizing = false;
      this.activeModelBuilding = false;
      this.activeModelSelection = false;
      this.activeModelTraining = false;
      this.activeHyperparametersOptimization = false;
      this.activeModelTesting = false;
      this.activeModelExporting = false;
      if (section == 'activeMachineLearningPipelineinD2') {
        this.activeMachineLearningPipelineinD2 = true;
      } else if (section == 'activePipelineComponentinDetails') {
        this.activePipelineComponentinDetails = true;
      } else if (section == 'activeRetrievalTrainingJobMetadata') {
        this.activeRetrievalTrainingJobMetadata = true;
      } else if (section == 'activeDataPreprocess') {
        this.activeDataPreprocess = true;
      } else if (section == 'activeDataLoading') {
        this.activeDataLoading = true;
      } else if (section == 'activeEDA') {
        this.activeEDA = true;
      } else if (section == 'activeDataSplitting') {
        this.activeDataSplitting = true;
      } else if (section == 'activeFeatureEngineering') {
        this.activeFeatureEngineering = true;
      } else if (section == 'activeDataNormalizing') {
        this.activeDataNormalizing = true;
      } else if (section == 'activeModelBuilding') {
        this.activeModelBuilding = true;
      } else if (section == 'activeModelSelection') {
        this.activeModelSelection = true;
      } else if (section == 'activeModelTraining') {
        this.activeModelTraining = true;
      } else if (section == 'activeHyperparametersOptimization') {
        this.activeHyperparametersOptimization = true;
      } else if (section == 'activeModelTesting') {
        this.activeModelTesting = true;
      } else if (section == 'activeModelExporting') {
        this.activeModelExporting = true;
      }
    }
  },
  mounted() {
    window.scrollTo(0, 0);
  }
};
const _withScopeId = n => (pushScopeId("data-v-f7867c81"), n = n(), popScopeId(), n);
const _hoisted_1 = {
  class: "row",
  style: {
    "column-gap": "10px"
  }
};
const _hoisted_2 = {
  class: "col"
};
const _hoisted_3 = {
  class: "row nav-text"
};
const _hoisted_4 = {
  class: "col"
};
const _hoisted_5 = /*#__PURE__*/_withScopeId(() => /*#__PURE__*/createBaseVNode("span", null, "Docs", -1));
const _hoisted_6 = /*#__PURE__*/_withScopeId(() => /*#__PURE__*/createBaseVNode("span", null, "Components", -1));
const _hoisted_7 = /*#__PURE__*/_withScopeId(() => /*#__PURE__*/createBaseVNode("span", null, "Machine Learning Pipeline", -1));
const _hoisted_8 = /*#__PURE__*/_withScopeId(() => /*#__PURE__*/createBaseVNode("span", null, "Pipeline Components", -1));
const _hoisted_9 = /*#__PURE__*/_withScopeId(() => /*#__PURE__*/createBaseVNode("div", {
  class: "title"
}, [/*#__PURE__*/createBaseVNode("span", null, "Pipeline Components")], -1));
const _hoisted_10 = /*#__PURE__*/_withScopeId(() => /*#__PURE__*/createBaseVNode("div", {
  class: "subtitle"
}, [/*#__PURE__*/createBaseVNode("span", null, "The details of components of Machine Learning Pipelines")], -1));
const _hoisted_11 = {
  class: "col-3"
};
const _hoisted_12 = {
  style: {
    "position": "sticky",
    "top": "20px",
    "color": "#888888"
  }
};
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
  const _component_markdown_viewer = resolveComponent("markdown-viewer");
  return openBlock(), createElementBlock("div", _hoisted_1, [createBaseVNode("div", _hoisted_2, [createBaseVNode("div", _hoisted_3, [createBaseVNode("div", _hoisted_4, [createVNode(QBreadcrumbs, null, {
    default: withCtx(() => [createVNode(QBreadcrumbsEl, {
      to: "/docs"
    }, {
      default: withCtx(() => [_hoisted_5]),
      _: 1
    }), createVNode(QBreadcrumbsEl, {
      to: "/docs/components"
    }, {
      default: withCtx(() => [_hoisted_6]),
      _: 1
    }), createVNode(QBreadcrumbsEl, {
      to: "/docs/components/mlpipeline/"
    }, {
      default: withCtx(() => [_hoisted_7]),
      _: 1
    }), createVNode(QBreadcrumbsEl, {
      to: "/docs/components/mlpipeline/mlpipeline-components"
    }, {
      default: withCtx(() => [_hoisted_8]),
      _: 1
    })]),
    _: 1
  })])]), _hoisted_9, _hoisted_10, createVNode(QSeparator), createBaseVNode("div", null, [createVNode(_component_markdown_viewer, {
    value: $data.value
  }, null, 8, ["value"])])]), createBaseVNode("div", _hoisted_11, [createBaseVNode("div", _hoisted_12, [createVNode(QList, {
    dense: ""
  }, {
    default: withCtx(() => [createVNode(QItem, {
      active: $data.activeMachineLearningPipelineinD2,
      "active-class": "text-bold",
      "manual-focus": "",
      dense: "",
      clickable: "",
      to: {
        hash: '#machine-learning-pipeline-in-d2-system'
      },
      onClick: _cache[0] || (_cache[0] = $event => $options.setActive('activeMachineLearningPipelineinD2'))
    }, {
      default: withCtx(() => [createVNode(QItemSection, {
        class: "q-item-text"
      }, {
        default: withCtx(() => [createTextVNode("Machine learning pipeline in D2 System")]),
        _: 1
      })]),
      _: 1
    }, 8, ["active"]), createVNode(QItem, {
      active: $data.activePipelineComponentinDetails,
      "active-class": "text-bold",
      "manual-focus": "",
      dense: "",
      clickable: "",
      to: {
        hash: '#pipeline-components-in-details'
      },
      onClick: _cache[1] || (_cache[1] = $event => $options.setActive('activePipelineComponentinDetails'))
    }, {
      default: withCtx(() => [createVNode(QItemSection, {
        class: "q-item-text"
      }, {
        default: withCtx(() => [createTextVNode("Pipeline Components in Details")]),
        _: 1
      })]),
      _: 1
    }, 8, ["active"]), createVNode(QItem, {
      "inset-level": 0.5
    }, {
      default: withCtx(() => [createVNode(QList, {
        dense: ""
      }, {
        default: withCtx(() => [createVNode(QItem, {
          active: $data.activeRetrievalTrainingJobMetadata,
          "active-class": "text-bold",
          "manual-focus": "",
          dense: "",
          clickable: "",
          to: {
            hash: '#retrieval-of-training-job-metadata'
          },
          onClick: _cache[2] || (_cache[2] = $event => $options.setActive('activeRetrievalTrainingJobMetadata'))
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Retrieval of Training Job Metadata")]),
            _: 1
          })]),
          _: 1
        }, 8, ["active"]), createVNode(QItem, {
          active: $data.activeDataPreprocess,
          "active-class": "text-bold",
          "manual-focus": "",
          dense: "",
          clickable: "",
          to: {
            hash: '#data-pre-processing'
          },
          onClick: _cache[3] || (_cache[3] = $event => $options.setActive('activeDataPreprocess'))
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Data Pre-processing")]),
            _: 1
          })]),
          _: 1
        }, 8, ["active"]), createVNode(QItem, {
          "inset-level": 0.5
        }, {
          default: withCtx(() => [createVNode(QList, {
            dense: ""
          }, {
            default: withCtx(() => [createVNode(QItem, {
              active: $data.activeDataLoading,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#1.-data-loading'
              },
              onClick: _cache[4] || (_cache[4] = $event => $options.setActive('activeDataLoading'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("1. Data Loading")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active", "to"]), createVNode(QItem, {
              active: $data.activeEDA,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#2.-exploratory-data-analysis-(eda)'
              },
              onClick: _cache[5] || (_cache[5] = $event => $options.setActive('activeEDA'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("2. Exploratory Data Analysis (EDA)")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active", "to"]), createVNode(QItem, {
              active: $data.activeDataSplitting,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#3.-data-splitting'
              },
              onClick: _cache[6] || (_cache[6] = $event => $options.setActive('activeDataSplitting'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("3. Data Splitting")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active", "to"]), createVNode(QItem, {
              active: $data.activeFeatureEngineering,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#4.-feature-engineering'
              },
              onClick: _cache[7] || (_cache[7] = $event => $options.setActive('activeFeatureEngineering'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("4. Feature Engineering")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active", "to"]), createVNode(QItem, {
              active: $data.activeDataNormalizing,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#5.-data-normalizing'
              },
              onClick: _cache[8] || (_cache[8] = $event => $options.setActive('activeDataNormalizing'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("5. Data Normalizing")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active", "to"])]),
            _: 1
          })]),
          _: 1
        }, 8, ["inset-level"]), createVNode(QItem, {
          active: $data.activeModelBuilding,
          "active-class": "text-bold",
          "manual-focus": "",
          dense: "",
          clickable: "",
          to: {
            hash: '#model-building'
          },
          onClick: _cache[9] || (_cache[9] = $event => $options.setActive('activeModelBuilding'))
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Model Building")]),
            _: 1
          })]),
          _: 1
        }, 8, ["active"]), createVNode(QItem, {
          "inset-level": 0.5
        }, {
          default: withCtx(() => [createVNode(QList, {
            dense: ""
          }, {
            default: withCtx(() => [createVNode(QItem, {
              active: $data.activeModelSelection,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#model-selection'
              },
              onClick: _cache[10] || (_cache[10] = $event => $options.setActive('activeModelSelection'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Model Selection")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active"]), createVNode(QItem, {
              active: $data.activeModelTraining,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#model-training'
              },
              onClick: _cache[11] || (_cache[11] = $event => $options.setActive('activeModelTraining'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Model Training")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active"]), createVNode(QItem, {
              active: $data.activeHyperparametersOptimization,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#hyperparameters-optimization'
              },
              onClick: _cache[12] || (_cache[12] = $event => $options.setActive('activeHyperparametersOptimization'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Hyperparameters Optimization")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active"]), createVNode(QItem, {
              active: $data.activeModelTesting,
              "active-class": "text-bold",
              "manual-focus": "",
              dense: "",
              clickable: "",
              to: {
                hash: '#model-testing'
              },
              onClick: _cache[13] || (_cache[13] = $event => $options.setActive('activeModelTesting'))
            }, {
              default: withCtx(() => [createVNode(QItemSection, {
                class: "q-item-text"
              }, {
                default: withCtx(() => [createTextVNode("Model Testing")]),
                _: 1
              })]),
              _: 1
            }, 8, ["active"])]),
            _: 1
          })]),
          _: 1
        }, 8, ["inset-level"]), createVNode(QItem, {
          active: $data.activeModelExporting,
          "active-class": "text-bold",
          "manual-focus": "",
          dense: "",
          clickable: "",
          to: {
            hash: '#model-exporting'
          },
          onClick: _cache[14] || (_cache[14] = $event => $options.setActive('activeModelExporting'))
        }, {
          default: withCtx(() => [createVNode(QItemSection, {
            class: "q-item-text"
          }, {
            default: withCtx(() => [createTextVNode("Model Exporting")]),
            _: 1
          })]),
          _: 1
        }, 8, ["active"])]),
        _: 1
      })]),
      _: 1
    }, 8, ["inset-level"])]),
    _: 1
  })])])]);
}
const pipelineComponents = /*#__PURE__*/_export_sfc(_sfc_main, [['render', _sfc_render], ['__scopeId', "data-v-f7867c81"]]);

export { pipelineComponents as default };
