Add new SentenceTransformer model.

1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+  "word_embedding_dimension": 384,
+  "pooling_mode_cls_token": false,
+  "pooling_mode_mean_tokens": true,
+  "pooling_mode_max_tokens": false,
+  "pooling_mode_mean_sqrt_len_tokens": false,
+  "pooling_mode_weightedmean_tokens": false,
+  "pooling_mode_lasttoken": false,
+  "include_prompt": true
+}

README.md

@@ -0,0 +1,1687 @@
+---
+base_model: sentence-transformers/all-MiniLM-L6-v2
+datasets: []
+language:
+- en
+library_name: sentence-transformers
+license: apache-2.0
+metrics:
+- cosine_accuracy@1
+- cosine_accuracy@3
+- cosine_accuracy@5
+- cosine_accuracy@10
+- cosine_precision@1
+- cosine_precision@3
+- cosine_precision@5
+- cosine_precision@10
+- cosine_recall@1
+- cosine_recall@3
+- cosine_recall@5
+- cosine_recall@10
+- cosine_ndcg@10
+- cosine_mrr@10
+- cosine_map@100
+pipeline_tag: sentence-similarity
+tags:
+- sentence-transformers
+- sentence-similarity
+- feature-extraction
+- generated_from_trainer
+- dataset_size:1490
+- loss:MatryoshkaLoss
+- loss:MultipleNegativesRankingLoss
+widget:
+- source_sentence: Can you explain how to override the extract_metadata() method to
+    track custom metadata for artifacts in ZenML?
+  sentences:
+  - 'tional) Which Metadata to Extract for the ArtifactOptionally, you can override
+    the extract_metadata() method to track custom metadata for all artifacts saved
+    by your materializer. Anything you extract here will be displayed in the dashboard
+    next to your artifacts.
+
+
+    src.zenml.metadata.metadata_types that are displayed in a dedicated way in the
+    dashboard. See
+
+
+    src.zenml.metadata.metadata_types.MetadataType for more details.
+
+
+    By default, this method will only extract the storage size of an artifact, but
+    you can overwrite it to track anything you wish. E.g., the zenml.materializers.NumpyMaterializer
+    overwrites this method to track the shape, dtype, and some statistical properties
+    of each np.ndarray that it saves.
+
+
+    If you would like to disable artifact metadata extraction altogether, you can
+    set enable_artifact_metadata at either pipeline or step level via @pipeline(enable_artifact_metadata=False)
+    or @step(enable_artifact_metadata=False).
+
+
+    Skipping materialization
+
+
+    Skipping materialization might have unintended consequences for downstream tasks
+    that rely on materialized artifacts. Only skip materialization if there is no
+    other way to do what you want to do.
+
+
+    While materializers should in most cases be used to control how artifacts are
+    returned and consumed from pipeline steps, you might sometimes need to have a
+    completely unmaterialized artifact in a step, e.g., if you need to know the exact
+    path to where your artifact is stored.
+
+
+    An unmaterialized artifact is a zenml.materializers.UnmaterializedArtifact. Among
+    others, it has a property uri that points to the unique path in the artifact store
+    where the artifact is persisted. One can use an unmaterialized artifact by specifying
+    UnmaterializedArtifact as the type in the step:
+
+
+    from zenml.artifacts.unmaterialized_artifact import UnmaterializedArtifact
+
+
+    from zenml import step
+
+
+    @step
+
+
+    def my_step(my_artifact: UnmaterializedArtifact):  # rather than pd.DataFrame
+
+
+    pass
+
+
+    Example'
+  - '                                                 ┃┃                                      │                 │                │                       │
+    HTTP response headers: HTTPHeaderDict({''Audit-Id'': ''72558f83-e050-4fe3-93e5-9f7e66988a4c'',
+    ''Cache-Control'':   ┃
+
+
+    ┃                                      │                 │                │                       │
+    ''no-cache, private'', ''Content-Type'': ''application/json'', ''Date'': ''Fri,
+    09 Jun 2023 18:59:02 GMT'',             ┃
+
+
+    ┃                                      │                 │                │                       │
+    ''Content-Length'': ''129''})                                                                                     ┃
+
+
+    ┃                                      │                 │                │                       │
+    HTTP response body:                                                                                           ┃
+
+
+    ┃                                      │                 │                │                       │
+    {"kind":"Status","apiVersion":"v1","metadata":{},"status":"Failure","message":"Unauthorized","reason":"Unauth
+    ┃
+
+
+    ┃                                      │                 │                │                       │
+    orized","code":401}                                                                                           ┃
+
+
+    ┃                                      │                 │                │                       │                                                                                                               ┃
+
+
+    ┃                                      │                 │                │                       │                                                                                                               ┃
+
+
+    ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷��━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛'
+  - 's/30267569827/locations/global/workloadIdentityP ┃┃                       │ ools/mypool/providers/myprovider",                                            ┃
+
+
+    ┃                       │   "subject_token_type": "urn:ietf:params:aws:token-type:aws4_request",        ┃
+
+
+    ┃                       │   "service_account_impersonation_url":                                        ┃
+
+
+    ┃                       │ "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/myrole@  ┃
+
+
+    ┃                       │ zenml-core.iam.gserviceaccount.com:generateAccessToken",                      ┃
+
+
+    ┃                       │   "token_url": "https://sts.googleapis.com/v1/token",                         ┃
+
+
+    ┃                       │   "credential_source": {                                                      ┃
+
+
+    ┃                       │     "environment_id": "aws1",                                                 ┃
+
+
+    ┃                       │     "region_url":                                                             ┃
+
+
+    ┃                       │ "http://169.254.169.254/latest/meta-data/placement/availability-zone",        ┃
+
+
+    ┃                       │     "url":                                                                    ┃
+
+
+    ┃                       │ "http://169.254.169.254/latest/meta-data/iam/security-credentials",           ┃
+
+
+    ┃                       │     "regional_cred_verification_url":                                         ┃
+
+
+    ┃                       │ "https://sts.{region}.amazonaws.com?Action=GetCallerIdentity&Version=2011-06-
+    ┃
+
+
+    ┃                       │ 15"                                                                           ┃
+
+
+    ┃                       │   }                                                                           ┃
+
+
+    ┃                       │ }                                                                             ┃
+
+
+    ┗━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+
+    GCP OAuth 2.0 token'
+- source_sentence: How does the `sync_new_data_to_label_studio` step ensure that new
+    annotations remain in sync with the ZenML artifact store?
+  sentences:
+  - 'nf,
+
+
+    step_config: "StepConfiguration",
+
+
+    ) -> None:"""Configures Spark to handle backends like YARN, Mesos or Kubernetes."""
+
+
+    def _io_configuration(
+
+
+    self,
+
+
+    spark_config: SparkConf
+
+
+    ) -> None:
+
+
+    """Configures Spark to handle different input/output sources."""
+
+
+    def _additional_configuration(
+
+
+    self,
+
+
+    spark_config: SparkConf
+
+
+    ) -> None:
+
+
+    """Appends the user-defined configuration parameters."""
+
+
+    def _launch_spark_job(
+
+
+    self,
+
+
+    spark_config: SparkConf,
+
+
+    entrypoint_command: List[str]
+
+
+    ) -> None:
+
+
+    """Generates and executes a spark-submit command."""
+
+
+    def launch(
+
+
+    self,
+
+
+    info: "StepRunInfo",
+
+
+    entrypoint_command: List[str],
+
+
+    ) -> None:
+
+
+    """Launches the step on Spark."""
+
+
+    Under the base configuration, you will see the main configuration parameters:
+
+
+    master is the master URL for the cluster where Spark will run. You might see different
+    schemes for this URL with varying cluster managers such as Mesos, YARN, or Kubernetes.
+
+
+    deploy_mode can either be ''cluster'' (default) or ''client'' and it decides where
+    the driver node of the application will run.
+
+
+    submit_args is the JSON string of a dictionary, which will be used to define additional
+    parameters if required ( Spark has a wide variety of parameters, thus including
+    them all in a single class was deemed unnecessary.).
+
+
+    In addition to this configuration, the launch method of the step operator gets
+    additional configuration parameters from the DockerSettings and ResourceSettings.
+    As a result, the overall configuration happens in 4 base methods:
+
+
+    _resource_configuration translates the ZenML ResourceSettings object to Spark''s
+    own resource configuration.
+
+
+    _backend_configuration is responsible for cluster-manager-specific configuration.
+
+
+    _io_configuration is a critical method. Even though we have materializers, Spark
+    might require additional packages and configuration to work with a specific filesystem.
+    This method is used as an interface to provide this configuration.
+
+
+    _additional_configuration takes the submit_args, converts, and appends them to
+    the overall configuration.'
+  - 'Azure Blob Storage
+
+
+    Storing artifacts using Azure Blob Storage
+
+
+    The Azure Artifact Store is an Artifact Store flavor provided with the Azure ZenML
+    integration that uses the Azure Blob Storage managed object storage service to
+    store ZenML artifacts in an Azure Blob Storage container.
+
+
+    When would you want to use it?
+
+
+    Running ZenML pipelines with the local Artifact Store is usually sufficient if
+    you just want to evaluate ZenML or get started quickly without incurring the trouble
+    and the cost of employing cloud storage services in your stack. However, the local
+    Artifact Store becomes insufficient or unsuitable if you have more elaborate needs
+    for your project:
+
+
+    if you want to share your pipeline run results with other team members or stakeholders
+    inside or outside your organization
+
+
+    if you have other components in your stack that are running remotely (e.g. a Kubeflow
+    or Kubernetes Orchestrator running in a public cloud).
+
+
+    if you outgrow what your local machine can offer in terms of storage space and
+    need to use some form of private or public storage service that is shared with
+    others
+
+
+    if you are running pipelines at scale and need an Artifact Store that can handle
+    the demands of production-grade MLOps
+
+
+    In all these cases, you need an Artifact Store that is backed by a form of public
+    cloud or self-hosted shared object storage service.
+
+
+    You should use the Azure Artifact Store when you decide to keep your ZenML artifacts
+    in a shared object storage and if you have access to the Azure Blob Storage managed
+    service. You should consider one of the other Artifact Store flavors if you don''t
+    have access to the Azure Blob Storage service.
+
+
+    How do you deploy it?
+
+
+    The Azure Artifact Store flavor is provided by the Azure ZenML integration, you
+    need to install it on your local machine to be able to register an Azure Artifact
+    Store and add it to your stack:
+
+
+    zenml integration install azure -y'
+  - 'th the appropriate label config with Label Studio.get_labeled_data step - This
+    step will get all labeled data available for a particular dataset. Note that these
+    are output in a Label Studio annotation format, which will subsequently be converted
+    into a format appropriate for your specific use case.
+
+
+    sync_new_data_to_label_studio step - This step is for ensuring that ZenML is handling
+    the annotations and that the files being used are stored and synced with the ZenML
+    artifact store. This is an important step as part of a continuous annotation workflow
+    since you want all the subsequent steps of your workflow to remain in sync with
+    whatever new annotations are being made or have been created.
+
+
+    Helper Functions
+
+
+    Label Studio requires the use of what it calls ''label config'' when you are creating/registering
+    your dataset. These are strings containing HTML-like syntax that allow you to
+    define a custom interface for your annotation. ZenML provides three helper functions
+    that will construct these label config strings in the case of object detection,
+    image classification, and OCR. See the integrations.label_studio.label_config_generators
+    module for those three functions.
+
+
+    PreviousArgilla
+
+
+    NextPigeon
+
+
+    Last updated 15 days ago'
+- source_sentence: How can I register an orchestrator in our active stack using a
+    Service Connector?
+  sentences:
+  - 'in our active stack. This can be done in two ways:If you have a Service Connector
+    configured to access the remote Kubernetes cluster, you no longer need to set
+    the kubernetes_context attribute to a local kubectl context. In fact, you don''t
+    need the local Kubernetes CLI at all. You can connect the stack component to the
+    Service Connector instead:Copy$ zenml orchestrator register <ORCHESTRATOR_NAME>
+    --flavor tekton
+
+    Running with active workspace: ''default'' (repository)
+
+    Running with active stack: ''default'' (repository)
+
+    Successfully registered orchestrator `<ORCHESTRATOR_NAME>`.
+
+
+    $ zenml service-connector list-resources --resource-type kubernetes-cluster -e
+
+    The following ''kubernetes-cluster'' resources can be accessed by service connectors
+    configured in your workspace:
+
+    ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━��━━┯━━━━━━━━━━━━━━━━━━━━━┓
+
+    ┃             CONNECTOR ID             │ CONNECTOR NAME        │ CONNECTOR TYPE
+    │ RESOURCE TYPE         │ RESOURCE NAMES      ┃
+
+    ┠──────────────────────────────────────┼───────────────────────┼────────────────┼───────────────────────┼─────────────────────┨
+
+    ┃ e33c9fac-5daa-48b2-87bb-0187d3782cde │ aws-iam-multi-eu      │ 🔶 aws         │
+    🌀 kubernetes-cluster │ kubeflowmultitenant ┃
+
+    ┃                                      │                       │                │                       │
+    zenbox              ┃
+
+    ┠──────────────────────────────────────┼───────────────────────┼────────────────┼───────────────────────┼─────────────────────┨
+
+    ┃ ed528d5a-d6cb-4fc4-bc52-c3d2d01643e5 │ aws-iam-multi-us      │ 🔶 aws         │
+    🌀 kubernetes-cluster │ zenhacks-cluster    ┃
+
+    ┠──────────────────────────────────────┼───────────────────────┼────────────────┼───────────────────────┼─────────────────────┨
+
+    ┃ 1c54b32a-4889-4417-abbd-42d3ace3d03a │ gcp-sa-multi          │ 🔵 gcp         │
+    🌀 kubernetes-cluster │ zenml-test-cluster  ┃
+
+    ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━┛'
+  - 'e by passing the page argument to the list method.You can further restrict your
+    search by passing additional arguments that will be used to filter the results.
+    E.g., most resources have a user_id associated with them that can be set to only
+    list resources created by that specific user. The available filter argument options
+    are different for each list method; check out the method declaration in the Client
+    SDK documentation to find out which exact arguments are supported or have a look
+    at the fields of the corresponding filter model class.
+
+
+    Except for pipeline runs, all other resources will by default be ordered by creation
+    time ascending. E.g., client.list_artifacts() would return the first 50 artifacts
+    ever created. You can change the ordering by specifying the sort_by argument when
+    calling list methods.
+
+
+    Get Methods
+
+
+    Fetch a specific instance of a resource by either resource ID, name, or name prefix,
+    e.g.:
+
+
+    client.get_pipeline_run("413cfb42-a52c-4bf1-a2fd-78af2f7f0101")  # ID
+
+
+    client.get_pipeline_run("first_pipeline-2023_06_20-16_20_13_274466")  # Name
+
+
+    client.get_pipeline_run("first_pipeline-2023_06_20-16")  # Name prefix
+
+
+    Create, Update, and Delete Methods
+
+
+    Methods for creating / updating / deleting resources are only available for some
+    of the resources and the required arguments are different for each resource. Checkout
+    the Client SDK Documentation to find out whether a specific resource supports
+    write operations through the Client and which arguments are required.
+
+
+    Active User and Active Stack
+
+
+    For some use cases you might need to know information about the user that you
+    are authenticated as or the stack that you have currently set as active. You can
+    fetch this information via the client.active_user and client.active_stack_model
+    properties respectively, e.g.:
+
+
+    my_runs_on_current_stack = client.list_pipeline_runs(
+
+
+    stack_id=client.active_stack_model.id,  # on current stack
+
+
+    user_id=client.active_user.id,  # ran by you
+
+
+    Resource Models'
+  - ' build to finish. More information: Build Timeout.We can register the image builder
+    and use it in our active stack:
+
+
+    zenml image-builder register <IMAGE_BUILDER_NAME> \
+
+
+    --flavor=gcp \
+
+
+    --cloud_builder_image=<BUILDER_IMAGE_NAME> \
+
+
+    --network=<DOCKER_NETWORK> \
+
+
+    --build_timeout=<BUILD_TIMEOUT_IN_SECONDS>
+
+
+    # Register and activate a stack with the new image builder
+
+
+    zenml stack register <STACK_NAME> -i <IMAGE_BUILDER_NAME> ... --set
+
+
+    You also need to set up authentication required to access the Cloud Build GCP
+    services.
+
+
+    Authentication Methods
+
+
+    Integrating and using a GCP Image Builder in your pipelines is not possible without
+    employing some form of authentication. If you''re looking for a quick way to get
+    started locally, you can use the Local Authentication method. However, the recommended
+    way to authenticate to the GCP cloud platform is through a GCP Service Connector.
+    This is particularly useful if you are configuring ZenML stacks that combine the
+    GCP Image Builder with other remote stack components also running in GCP.
+
+
+    This method uses the implicit GCP authentication available in the environment
+    where the ZenML code is running. On your local machine, this is the quickest way
+    to configure a GCP Image Builder. You don''t need to supply credentials explicitly
+    when you register the GCP Image Builder, as it leverages the local credentials
+    and configuration that the Google Cloud CLI stores on your local machine. However,
+    you will need to install and set up the Google Cloud CLI on your machine as a
+    prerequisite, as covered in the Google Cloud documentation , before you register
+    the GCP Image Builder.
+
+
+    Stacks using the GCP Image Builder set up with local authentication are not portable
+    across environments. To make ZenML pipelines fully portable, it is recommended
+    to use a GCP Service Connector to authenticate your GCP Image Builder to the GCP
+    cloud platform.'
+- source_sentence: How can ZenML load and display visualizations from the artifact
+    store?
+  sentences:
+  - 'Connect with a Service Account
+
+
+    Sometimes you may need to authenticate to a ZenML server from a non-interactive
+    environment where the web login is not possible, like a CI/CD workload or a serverless
+    function. In these cases, you can configure a service account and an API key and
+    use the API key to authenticate to the ZenML server:
+
+
+    zenml service-account create <SERVICE_ACCOUNT_NAME>
+
+
+    This command creates a service account and an API key for it. The API key is displayed
+    as part of the command output and cannot be retrieved later. You can then use
+    the issued API key to connect your ZenML client to the server through one of the
+    following methods:
+
+
+    using the CLI:
+
+
+    zenml connect --url https://... --api-key <API_KEY>
+
+
+    setting the ZENML_STORE_URL and ZENML_STORE_API_KEY environment variables when
+    you set up your ZenML client for the first time. This method is particularly useful
+    when you are using the ZenML client in an automated CI/CD workload environment
+    like GitHub Actions or GitLab CI or in a containerized environment like Docker
+    or Kubernetes:
+
+
+    export ZENML_STORE_URL=https://...
+
+
+    export ZENML_STORE_API_KEY=<API_KEY>
+
+
+    To see all the service accounts you''ve created and their API keys, use the following
+    commands:
+
+
+    zenml service-account list
+
+
+    zenml service-account api-key <SERVICE_ACCOUNT_NAME> list
+
+
+    Additionally, the following command allows you to more precisely inspect one of
+    these service accounts and an API key:
+
+
+    zenml service-account describe <SERVICE_ACCOUNT_NAME>
+
+
+    zenml service-account api-key <SERVICE_ACCOUNT_NAME> describe <API_KEY_NAME>
+
+
+    API keys don''t have an expiration date. For increased security, we recommend
+    that you regularly rotate the API keys to prevent unauthorized access to your
+    ZenML server. You can do this with the ZenML CLI:
+
+
+    zenml service-account api-key <SERVICE_ACCOUNT_NAME> rotate <API_KEY_NAME>'
+  - 'd_data_loader_step()
+
+
+    # Load the model to finetune# If no version is specified, the latest version of
+    "my_model" is used
+
+
+    model = client.get_artifact_version(
+
+
+    name_id_or_prefix="my_model", version=model_version
+
+
+    # Finetune the model
+
+
+    # This automatically creates a new version of "my_model"
+
+
+    model_finetuner_step(model=model, dataset=dataset)
+
+
+    def main():
+
+
+    # Save an untrained model as first version of "my_model"
+
+
+    untrained_model = SVC(gamma=0.001)
+
+
+    save_artifact(
+
+
+    untrained_model, name="my_model", version="1", tags=["SVC", "untrained"]
+
+
+    # Create a first version of "my_dataset" and train the model on it
+
+
+    model_finetuning_pipeline()
+
+
+    # Finetune the latest model on an older version of the dataset
+
+
+    model_finetuning_pipeline(dataset_version="1")
+
+
+    # Run inference with the latest model on an older version of the dataset
+
+
+    latest_trained_model = load_artifact("my_model")
+
+
+    old_dataset = load_artifact("my_dataset", version="1")
+
+
+    latest_trained_model.predict(old_dataset[0])
+
+
+    if __name__ == "__main__":
+
+
+    main()
+
+
+    This would create the following pipeline run DAGs:
+
+
+    Run 1:
+
+
+    Run 2:
+
+
+    PreviousCache previous executions
+
+
+    NextTrack ML models
+
+
+    Last updated 19 days ago'
+  - 'into play when the component is ultimately in use.The design behind this interaction
+    lets us separate the configuration of the flavor from its implementation. This
+    way we can register flavors and components even when the major dependencies behind
+    their implementation are not installed in our local setting (assuming the CustomArtifactStoreFlavor
+    and the CustomArtifactStoreConfig are implemented in a different module/path than
+    the actual CustomArtifactStore).
+
+
+    Enabling Artifact Visualizations with Custom Artifact Stores
+
+
+    ZenML automatically saves visualizations for many common data types and allows
+    you to view these visualizations in the ZenML dashboard. Under the hood, this
+    works by saving the visualizations together with the artifacts in the artifact
+    store.
+
+
+    In order to load and display these visualizations, ZenML needs to be able to load
+    and access the corresponding artifact store. This means that your custom artifact
+    store needs to be configured in a way that allows authenticating to the back-end
+    without relying on the local environment, e.g., by embedding the authentication
+    credentials in the stack component configuration or by referencing a secret.
+
+
+    Furthermore, for deployed ZenML instances, you need to install the package dependencies
+    of your artifact store implementation in the environment where you have deployed
+    ZenML. See the Documentation on deploying ZenML with custom Docker images for
+    more information on how to do that.
+
+
+    PreviousAzure Blob Storage
+
+
+    NextContainer Registries
+
+
+    Last updated 19 days ago'
+- source_sentence: How do you configure ED25519 key based authentication for the HyperAI
+    orchestrator in ZenML?
+  sentences:
+  - 'authentication.
+
+
+    ED25519 key based authentication.SSH private keys configured in the connector
+    will be distributed to all clients that use them to run pipelines with the HyperAI
+    orchestrator. SSH keys are long-lived credentials that give unrestricted access
+    to HyperAI instances.
+
+
+    When configuring the Service Connector, it is required to provide at least one
+    hostname via hostnames and the username with which to login. Optionally, it is
+    possible to provide an ssh_passphrase if applicable. This way, it is possible
+    to use the HyperAI service connector in multiple ways:
+
+
+    Create one service connector per HyperAI instance with different SSH keys.
+
+
+    Configure a reused SSH key just once for multiple HyperAI instances, then select
+    the individual instance when creating the HyperAI orchestrator component.
+
+
+    Auto-configuration
+
+
+    This Service Connector does not support auto-discovery and extraction of authentication
+    credentials from HyperAI instances. If this feature is useful to you or your organization,
+    please let us know by messaging us in Slack or creating an issue on GitHub.
+
+
+    Stack Components use
+
+
+    The HyperAI Service Connector can be used by the HyperAI Orchestrator to deploy
+    pipeline runs to HyperAI instances.
+
+
+    PreviousAzure Service Connector
+
+
+    NextManage stacks
+
+
+    Last updated 15 days ago'
+  - 'nswer is satisfactory, or ''NO'' if it is not.",
+
+
+    },"role": "user",
+
+
+    "content": f"Question: {question}\nExpected Answer: {expected_answer}\nGenerated
+    Answer: {generated_answer}\nIs the generated answer relevant and accurate?",
+
+
+    },
+
+
+    ],
+
+
+    model="gpt-3.5-turbo",
+
+
+    judgment = chat_completion.choices[0].message.content.strip().lower()
+
+
+    return judgment == "yes"
+
+
+    retrieval_scores = []
+
+
+    generation_scores = []
+
+
+    for item in eval_data:
+
+
+    retrieval_score = evaluate_retrieval(
+
+
+    item["question"], item["expected_answer"], corpus
+
+
+    retrieval_scores.append(retrieval_score)
+
+
+    generated_answer = answer_question(item["question"], corpus)
+
+
+    generation_score = evaluate_generation(
+
+
+    item["question"], item["expected_answer"], generated_answer
+
+
+    generation_scores.append(generation_score)
+
+
+    retrieval_accuracy = sum(retrieval_scores) / len(retrieval_scores)
+
+
+    generation_accuracy = sum(generation_scores) / len(generation_scores)
+
+
+    print(f"Retrieval Accuracy: {retrieval_accuracy:.2f}")
+
+
+    print(f"Generation Accuracy: {generation_accuracy:.2f}")
+
+
+    As you can see, we''ve added two evaluation functions: evaluate_retrieval and
+    evaluate_generation. The evaluate_retrieval function checks if the retrieved chunks
+    contain any words from the expected answer. The evaluate_generation function uses
+    OpenAI''s chat completion LLM to evaluate the quality of the generated answer.
+
+
+    We then loop through the evaluation data, which contains questions and expected
+    answers, and evaluate the retrieval and generation components of our RAG pipeline.
+    Finally, we calculate the accuracy of both components and print the results:
+
+
+    As you can see, we get 100% accuracy for both retrieval and generation in this
+    example. Not bad! The sections that follow will provide a more detailed and sophisticated
+    implementation of RAG evaluation, but this example shows how you can think about
+    it at a high level!
+
+
+    PreviousEvaluation and metrics
+
+
+    NextRetrieval evaluation
+
+
+    Last updated 19 days ago'
+  - ' have a look at the SDK docs .
+
+
+    How do you use it?To log information from a ZenML pipeline step using the Neptune
+    Experiment Tracker component in the active stack, you need to enable an experiment
+    tracker using the @step decorator. Then fetch the Neptune run object and use logging
+    capabilities as you would normally do. For example:
+
+
+    import numpy as np
+
+
+    import tensorflow as tf
+
+
+    from neptune_tensorflow_keras import NeptuneCallback
+
+
+    from zenml.integrations.neptune.experiment_trackers.run_state import (
+
+
+    get_neptune_run,
+
+
+    from zenml import step
+
+
+    @step(experiment_tracker="<NEPTUNE_TRACKER_STACK_COMPONENT_NAME>")
+
+
+    def tf_trainer(
+
+
+    x_train: np.ndarray,
+
+
+    y_train: np.ndarray,
+
+
+    x_val: np.ndarray,
+
+
+    y_val: np.ndarray,
+
+
+    epochs: int = 5,
+
+
+    lr: float = 0.001
+
+
+    ) -> tf.keras.Model:
+
+
+    ...
+
+
+    neptune_run = get_neptune_run()
+
+
+    model.fit(
+
+
+    x_train,
+
+
+    y_train,
+
+
+    epochs=epochs,
+
+
+    validation_data=(x_val, y_val),
+
+
+    callbacks=[
+
+
+    NeptuneCallback(run=neptune_run),
+
+
+    ],
+
+
+    metric = ...
+
+
+    neptune_run["<METRIC_NAME>"] = metric
+
+
+    Instead of hardcoding an experiment tracker name, you can also use the Client
+    to dynamically use the experiment tracker of your active stack:
+
+
+    from zenml.client import Client
+
+
+    experiment_tracker = Client().active_stack.experiment_tracker
+
+
+    @step(experiment_tracker=experiment_tracker.name)
+
+
+    def tf_trainer(...):
+
+
+    ...
+
+
+    Additional configuration
+
+
+    You can pass a set of tags to the Neptune run by using the NeptuneExperimentTrackerSettings
+    class, like in the example below:
+
+
+    import numpy as np
+
+
+    import tensorflow as tf
+
+
+    from zenml import step
+
+
+    from zenml.integrations.neptune.experiment_trackers.run_state import (
+
+
+    get_neptune_run,
+
+
+    from zenml.integrations.neptune.flavors import NeptuneExperimentTrackerSettings
+
+
+    neptune_settings = NeptuneExperimentTrackerSettings(tags={"keras", "mnist"})
+
+
+    @step(
+
+
+    experiment_tracker="<NEPTUNE_TRACKER_STACK_COMPONENT_NAME>",
+
+
+    settings={
+
+
+    "experiment_tracker.neptune": neptune_settings
+
+
+    def my_step(
+
+
+    x_test: np.ndarray,
+
+
+    y_test: np.ndarray,
+
+
+    model: tf.keras.Model,
+
+
+    ) -> float:
+
+
+    """Log metadata to Neptune run"""'
+model-index:
+- name: zenml/finetuned-all-MiniLM-L6-v2
+  results:
+  - task:
+      type: information-retrieval
+      name: Information Retrieval
+    dataset:
+      name: dim 384
+      type: dim_384
+    metrics:
+    - type: cosine_accuracy@1
+      value: 0.3313253012048193
+      name: Cosine Accuracy@1
+    - type: cosine_accuracy@3
+      value: 0.5963855421686747
+      name: Cosine Accuracy@3
+    - type: cosine_accuracy@5
+      value: 0.6867469879518072
+      name: Cosine Accuracy@5
+    - type: cosine_accuracy@10
+      value: 0.8072289156626506
+      name: Cosine Accuracy@10
+    - type: cosine_precision@1
+      value: 0.3313253012048193
+      name: Cosine Precision@1
+    - type: cosine_precision@3
+      value: 0.1987951807228915
+      name: Cosine Precision@3
+    - type: cosine_precision@5
+      value: 0.13734939759036144
+      name: Cosine Precision@5
+    - type: cosine_precision@10
+      value: 0.08072289156626504
+      name: Cosine Precision@10
+    - type: cosine_recall@1
+      value: 0.3313253012048193
+      name: Cosine Recall@1
+    - type: cosine_recall@3
+      value: 0.5963855421686747
+      name: Cosine Recall@3
+    - type: cosine_recall@5
+      value: 0.6867469879518072
+      name: Cosine Recall@5
+    - type: cosine_recall@10
+      value: 0.8072289156626506
+      name: Cosine Recall@10
+    - type: cosine_ndcg@10
+      value: 0.56403366334234
+      name: Cosine Ndcg@10
+    - type: cosine_mrr@10
+      value: 0.48697408682348453
+      name: Cosine Mrr@10
+    - type: cosine_map@100
+      value: 0.4930812678607045
+      name: Cosine Map@100
+  - task:
+      type: information-retrieval
+      name: Information Retrieval
+    dataset:
+      name: dim 256
+      type: dim_256
+    metrics:
+    - type: cosine_accuracy@1
+      value: 0.3373493975903614
+      name: Cosine Accuracy@1
+    - type: cosine_accuracy@3
+      value: 0.5963855421686747
+      name: Cosine Accuracy@3
+    - type: cosine_accuracy@5
+      value: 0.6746987951807228
+      name: Cosine Accuracy@5
+    - type: cosine_accuracy@10
+      value: 0.7771084337349398
+      name: Cosine Accuracy@10
+    - type: cosine_precision@1
+      value: 0.3373493975903614
+      name: Cosine Precision@1
+    - type: cosine_precision@3
+      value: 0.1987951807228915
+      name: Cosine Precision@3
+    - type: cosine_precision@5
+      value: 0.13493975903614455
+      name: Cosine Precision@5
+    - type: cosine_precision@10
+      value: 0.07771084337349397
+      name: Cosine Precision@10
+    - type: cosine_recall@1
+      value: 0.3373493975903614
+      name: Cosine Recall@1
+    - type: cosine_recall@3
+      value: 0.5963855421686747
+      name: Cosine Recall@3
+    - type: cosine_recall@5
+      value: 0.6746987951807228
+      name: Cosine Recall@5
+    - type: cosine_recall@10
+      value: 0.7771084337349398
+      name: Cosine Recall@10
+    - type: cosine_ndcg@10
+      value: 0.5551681743429259
+      name: Cosine Ndcg@10
+    - type: cosine_mrr@10
+      value: 0.4842656339644293
+      name: Cosine Mrr@10
+    - type: cosine_map@100
+      value: 0.4928559286742408
+      name: Cosine Map@100
+  - task:
+      type: information-retrieval
+      name: Information Retrieval
+    dataset:
+      name: dim 128
+      type: dim_128
+    metrics:
+    - type: cosine_accuracy@1
+      value: 0.3132530120481928
+      name: Cosine Accuracy@1
+    - type: cosine_accuracy@3
+      value: 0.5060240963855421
+      name: Cosine Accuracy@3
+    - type: cosine_accuracy@5
+      value: 0.5843373493975904
+      name: Cosine Accuracy@5
+    - type: cosine_accuracy@10
+      value: 0.7289156626506024
+      name: Cosine Accuracy@10
+    - type: cosine_precision@1
+      value: 0.3132530120481928
+      name: Cosine Precision@1
+    - type: cosine_precision@3
+      value: 0.1686746987951807
+      name: Cosine Precision@3
+    - type: cosine_precision@5
+      value: 0.11686746987951806
+      name: Cosine Precision@5
+    - type: cosine_precision@10
+      value: 0.07289156626506023
+      name: Cosine Precision@10
+    - type: cosine_recall@1
+      value: 0.3132530120481928
+      name: Cosine Recall@1
+    - type: cosine_recall@3
+      value: 0.5060240963855421
+      name: Cosine Recall@3
+    - type: cosine_recall@5
+      value: 0.5843373493975904
+      name: Cosine Recall@5
+    - type: cosine_recall@10
+      value: 0.7289156626506024
+      name: Cosine Recall@10
+    - type: cosine_ndcg@10
+      value: 0.5072091899807667
+      name: Cosine Ndcg@10
+    - type: cosine_mrr@10
+      value: 0.43864744693057955
+      name: Cosine Mrr@10
+    - type: cosine_map@100
+      value: 0.44825117444575807
+      name: Cosine Map@100
+  - task:
+      type: information-retrieval
+      name: Information Retrieval
+    dataset:
+      name: dim 64
+      type: dim_64
+    metrics:
+    - type: cosine_accuracy@1
+      value: 0.2469879518072289
+      name: Cosine Accuracy@1
+    - type: cosine_accuracy@3
+      value: 0.4819277108433735
+      name: Cosine Accuracy@3
+    - type: cosine_accuracy@5
+      value: 0.536144578313253
+      name: Cosine Accuracy@5
+    - type: cosine_accuracy@10
+      value: 0.6506024096385542
+      name: Cosine Accuracy@10
+    - type: cosine_precision@1
+      value: 0.2469879518072289
+      name: Cosine Precision@1
+    - type: cosine_precision@3
+      value: 0.1606425702811245
+      name: Cosine Precision@3
+    - type: cosine_precision@5
+      value: 0.10722891566265058
+      name: Cosine Precision@5
+    - type: cosine_precision@10
+      value: 0.0650602409638554
+      name: Cosine Precision@10
+    - type: cosine_recall@1
+      value: 0.2469879518072289
+      name: Cosine Recall@1
+    - type: cosine_recall@3
+      value: 0.4819277108433735
+      name: Cosine Recall@3
+    - type: cosine_recall@5
+      value: 0.536144578313253
+      name: Cosine Recall@5
+    - type: cosine_recall@10
+      value: 0.6506024096385542
+      name: Cosine Recall@10
+    - type: cosine_ndcg@10
+      value: 0.4454935545722587
+      name: Cosine Ndcg@10
+    - type: cosine_mrr@10
+      value: 0.38048384012239445
+      name: Cosine Mrr@10
+    - type: cosine_map@100
+      value: 0.39358543662682755
+      name: Cosine Map@100
+---
+
+# zenml/finetuned-all-MiniLM-L6-v2
+
+This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [sentence-transformers/all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2). It maps sentences & paragraphs to a 384-dimensional dense vector space and can be used for semantic textual similarity, semantic search, paraphrase mining, text classification, clustering, and more.
+
+## Model Details
+
+### Model Description
+- **Model Type:** Sentence Transformer
+- **Base model:** [sentence-transformers/all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) <!-- at revision 8b3219a92973c328a8e22fadcfa821b5dc75636a -->
+- **Maximum Sequence Length:** 256 tokens
+- **Output Dimensionality:** 384 tokens
+- **Similarity Function:** Cosine Similarity
+<!-- - **Training Dataset:** Unknown -->
+- **Language:** en
+- **License:** apache-2.0
+
+### Model Sources
+
+- **Documentation:** [Sentence Transformers Documentation](https://sbert.net)
+- **Repository:** [Sentence Transformers on GitHub](https://github.com/UKPLab/sentence-transformers)
+- **Hugging Face:** [Sentence Transformers on Hugging Face](https://huggingface.co/models?library=sentence-transformers)
+
+### Full Model Architecture
+
+```
+SentenceTransformer(
+  (0): Transformer({'max_seq_length': 256, 'do_lower_case': False}) with Transformer model: BertModel 
+  (1): Pooling({'word_embedding_dimension': 384, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
+  (2): Normalize()
+)
+```
+
+## Usage
+
+### Direct Usage (Sentence Transformers)
+
+First install the Sentence Transformers library:
+
+```bash
+pip install -U sentence-transformers
+```
+
+Then you can load this model and run inference.
+```python
+from sentence_transformers import SentenceTransformer
+
+# Download from the 🤗 Hub
+model = SentenceTransformer("zenml/finetuned-all-MiniLM-L6-v2")
+# Run inference
+sentences = [
+    'How do you configure ED25519 key based authentication for the HyperAI orchestrator in ZenML?',
+    'authentication.\n\nED25519 key based authentication.SSH private keys configured in the connector will be distributed to all clients that use them to run pipelines with the HyperAI orchestrator. SSH keys are long-lived credentials that give unrestricted access to HyperAI instances.\n\nWhen configuring the Service Connector, it is required to provide at least one hostname via hostnames and the username with which to login. Optionally, it is possible to provide an ssh_passphrase if applicable. This way, it is possible to use the HyperAI service connector in multiple ways:\n\nCreate one service connector per HyperAI instance with different SSH keys.\n\nConfigure a reused SSH key just once for multiple HyperAI instances, then select the individual instance when creating the HyperAI orchestrator component.\n\nAuto-configuration\n\nThis Service Connector does not support auto-discovery and extraction of authentication credentials from HyperAI instances. If this feature is useful to you or your organization, please let us know by messaging us in Slack or creating an issue on GitHub.\n\nStack Components use\n\nThe HyperAI Service Connector can be used by the HyperAI Orchestrator to deploy pipeline runs to HyperAI instances.\n\nPreviousAzure Service Connector\n\nNextManage stacks\n\nLast updated 15 days ago',
+    ' have a look at the SDK docs .\n\nHow do you use it?To log information from a ZenML pipeline step using the Neptune Experiment Tracker component in the active stack, you need to enable an experiment tracker using the @step decorator. Then fetch the Neptune run object and use logging capabilities as you would normally do. For example:\n\nimport numpy as np\n\nimport tensorflow as tf\n\nfrom neptune_tensorflow_keras import NeptuneCallback\n\nfrom zenml.integrations.neptune.experiment_trackers.run_state import (\n\nget_neptune_run,\n\nfrom zenml import step\n\n@step(experiment_tracker="<NEPTUNE_TRACKER_STACK_COMPONENT_NAME>")\n\ndef tf_trainer(\n\nx_train: np.ndarray,\n\ny_train: np.ndarray,\n\nx_val: np.ndarray,\n\ny_val: np.ndarray,\n\nepochs: int = 5,\n\nlr: float = 0.001\n\n) -> tf.keras.Model:\n\n...\n\nneptune_run = get_neptune_run()\n\nmodel.fit(\n\nx_train,\n\ny_train,\n\nepochs=epochs,\n\nvalidation_data=(x_val, y_val),\n\ncallbacks=[\n\nNeptuneCallback(run=neptune_run),\n\n],\n\nmetric = ...\n\nneptune_run["<METRIC_NAME>"] = metric\n\nInstead of hardcoding an experiment tracker name, you can also use the Client to dynamically use the experiment tracker of your active stack:\n\nfrom zenml.client import Client\n\nexperiment_tracker = Client().active_stack.experiment_tracker\n\n@step(experiment_tracker=experiment_tracker.name)\n\ndef tf_trainer(...):\n\n...\n\nAdditional configuration\n\nYou can pass a set of tags to the Neptune run by using the NeptuneExperimentTrackerSettings class, like in the example below:\n\nimport numpy as np\n\nimport tensorflow as tf\n\nfrom zenml import step\n\nfrom zenml.integrations.neptune.experiment_trackers.run_state import (\n\nget_neptune_run,\n\nfrom zenml.integrations.neptune.flavors import NeptuneExperimentTrackerSettings\n\nneptune_settings = NeptuneExperimentTrackerSettings(tags={"keras", "mnist"})\n\n@step(\n\nexperiment_tracker="<NEPTUNE_TRACKER_STACK_COMPONENT_NAME>",\n\nsettings={\n\n"experiment_tracker.neptune": neptune_settings\n\ndef my_step(\n\nx_test: np.ndarray,\n\ny_test: np.ndarray,\n\nmodel: tf.keras.Model,\n\n) -> float:\n\n"""Log metadata to Neptune run"""',
+]
+embeddings = model.encode(sentences)
+print(embeddings.shape)
+# [3, 384]
+
+# Get the similarity scores for the embeddings
+similarities = model.similarity(embeddings, embeddings)
+print(similarities.shape)
+# [3, 3]
+```
+
+<!--
+### Direct Usage (Transformers)
+
+<details><summary>Click to see the direct usage in Transformers</summary>
+
+</details>
+-->
+
+<!--
+### Downstream Usage (Sentence Transformers)
+
+You can finetune this model on your own dataset.
+
+<details><summary>Click to expand</summary>
+
+</details>
+-->
+
+<!--
+### Out-of-Scope Use
+
+*List how the model may foreseeably be misused and address what users ought not to do with the model.*
+-->
+
+## Evaluation
+
+### Metrics
+
+#### Information Retrieval
+* Dataset: `dim_384`
+* Evaluated with [<code>InformationRetrievalEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.InformationRetrievalEvaluator)
+
+| Metric              | Value      |
+|:--------------------|:-----------|
+| cosine_accuracy@1   | 0.3313     |
+| cosine_accuracy@3   | 0.5964     |
+| cosine_accuracy@5   | 0.6867     |
+| cosine_accuracy@10  | 0.8072     |
+| cosine_precision@1  | 0.3313     |
+| cosine_precision@3  | 0.1988     |
+| cosine_precision@5  | 0.1373     |
+| cosine_precision@10 | 0.0807     |
+| cosine_recall@1     | 0.3313     |
+| cosine_recall@3     | 0.5964     |
+| cosine_recall@5     | 0.6867     |
+| cosine_recall@10    | 0.8072     |
+| cosine_ndcg@10      | 0.564      |
+| cosine_mrr@10       | 0.487      |
+| **cosine_map@100**  | **0.4931** |
+
+#### Information Retrieval
+* Dataset: `dim_256`
+* Evaluated with [<code>InformationRetrievalEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.InformationRetrievalEvaluator)
+
+| Metric              | Value      |
+|:--------------------|:-----------|
+| cosine_accuracy@1   | 0.3373     |
+| cosine_accuracy@3   | 0.5964     |
+| cosine_accuracy@5   | 0.6747     |
+| cosine_accuracy@10  | 0.7771     |
+| cosine_precision@1  | 0.3373     |
+| cosine_precision@3  | 0.1988     |
+| cosine_precision@5  | 0.1349     |
+| cosine_precision@10 | 0.0777     |
+| cosine_recall@1     | 0.3373     |
+| cosine_recall@3     | 0.5964     |
+| cosine_recall@5     | 0.6747     |
+| cosine_recall@10    | 0.7771     |
+| cosine_ndcg@10      | 0.5552     |
+| cosine_mrr@10       | 0.4843     |
+| **cosine_map@100**  | **0.4929** |
+
+#### Information Retrieval
+* Dataset: `dim_128`
+* Evaluated with [<code>InformationRetrievalEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.InformationRetrievalEvaluator)
+
+| Metric              | Value      |
+|:--------------------|:-----------|
+| cosine_accuracy@1   | 0.3133     |
+| cosine_accuracy@3   | 0.506      |
+| cosine_accuracy@5   | 0.5843     |
+| cosine_accuracy@10  | 0.7289     |
+| cosine_precision@1  | 0.3133     |
+| cosine_precision@3  | 0.1687     |
+| cosine_precision@5  | 0.1169     |
+| cosine_precision@10 | 0.0729     |
+| cosine_recall@1     | 0.3133     |
+| cosine_recall@3     | 0.506      |
+| cosine_recall@5     | 0.5843     |
+| cosine_recall@10    | 0.7289     |
+| cosine_ndcg@10      | 0.5072     |
+| cosine_mrr@10       | 0.4386     |
+| **cosine_map@100**  | **0.4483** |
+
+#### Information Retrieval
+* Dataset: `dim_64`
+* Evaluated with [<code>InformationRetrievalEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.InformationRetrievalEvaluator)
+
+| Metric              | Value      |
+|:--------------------|:-----------|
+| cosine_accuracy@1   | 0.247      |
+| cosine_accuracy@3   | 0.4819     |
+| cosine_accuracy@5   | 0.5361     |
+| cosine_accuracy@10  | 0.6506     |
+| cosine_precision@1  | 0.247      |
+| cosine_precision@3  | 0.1606     |
+| cosine_precision@5  | 0.1072     |
+| cosine_precision@10 | 0.0651     |
+| cosine_recall@1     | 0.247      |
+| cosine_recall@3     | 0.4819     |
+| cosine_recall@5     | 0.5361     |
+| cosine_recall@10    | 0.6506     |
+| cosine_ndcg@10      | 0.4455     |
+| cosine_mrr@10       | 0.3805     |
+| **cosine_map@100**  | **0.3936** |
+
+<!--
+## Bias, Risks and Limitations
+
+*What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model.*
+-->
+
+<!--
+### Recommendations
+
+*What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.*
+-->
+
+## Training Details
+
+### Training Dataset
+
+#### Unnamed Dataset
+
+
+* Size: 1,490 training samples
+* Columns: <code>positive</code> and <code>anchor</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | positive                                                                          | anchor                                                                               |
+  |:--------|:----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|
+  | type    | string                                                                            | string                                                                               |
+  | details | <ul><li>min: 9 tokens</li><li>mean: 21.22 tokens</li><li>max: 49 tokens</li></ul> | <ul><li>min: 21 tokens</li><li>mean: 239.53 tokens</li><li>max: 256 tokens</li></ul> |
+* Samples:
+  | positive                                                                                                                | anchor                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+  |:------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+  | <code>What variables should be set for authenticating with the Azure Key Vault API when using ZenML?</code>             | <code>-client-id","client_secret": "my-client-secret"}).Note: The remaining configuration options are deprecated and may be removed in a future release. Instead, you should set the ZENML_SECRETS_STORE_AUTH_METHOD and ZENML_SECRETS_STORE_AUTH_CONFIG variables to use the Azure Service Connector authentication method.<br><br>ZENML_SECRETS_STORE_AZURE_CLIENT_ID: The Azure application service principal client ID to use to authenticate with the Azure Key Vault API. If you are running the ZenML server hosted in Azure and are using a managed identity to access the Azure Key Vault service, you can omit this variable.<br><br>ZENML_SECRETS_STORE_AZURE_CLIENT_SECRET: The Azure application service principal client secret to use to authenticate with the Azure Key Vault API. If you are running the ZenML server hosted in Azure and are using a managed identity to access the Azure Key Vault service, you can omit this variable.<br><br>ZENML_SECRETS_STORE_AZURE_TENANT_ID: The Azure application service principal tenant ID to use to authenticate with the Azure Key Vault API. If you are running the ZenML server hosted in Azure and are using a managed identity to access the Azure Key Vault service, you can omit this variable.<br><br>These configuration options are only relevant if you're using Hashicorp Vault as the secrets store backend.<br><br>ZENML_SECRETS_STORE_TYPE: Set this to hashicorp in order to set this type of secret store.<br><br>ZENML_SECRETS_STORE_VAULT_ADDR: The URL of the HashiCorp Vault server to connect to. NOTE: this is the same as setting the VAULT_ADDR environment variable.<br><br>ZENML_SECRETS_STORE_VAULT_TOKEN: The token to use to authenticate with the HashiCorp Vault server. NOTE: this is the same as setting the VAULT_TOKEN environment variable.<br><br>ZENML_SECRETS_STORE_VAULT_NAMESPACE: The Vault Enterprise namespace. Not required for Vault OSS. NOTE: this is the same as setting the VAULT_NAMESPACE environment variable.</code> |
+  | <code>How do I register and use the Azure Container Registry in ZenML?</code>                                           | <code>Azure Container Registry<br><br>Storing container images in Azure.<br><br>The Azure container registry is a container registry flavor that comes built-in with ZenML and uses the Azure Container Registry to store container images.<br><br>When to use it<br><br>You should use the Azure container registry if:<br><br>one or more components of your stack need to pull or push container images.<br><br>you have access to Azure. If you're not using Azure, take a look at the other container registry flavors.<br><br>How to deploy it<br><br>Go here and choose a subscription, resource group, location, and registry name. Then click on Review + Create and to create your container registry.<br><br>How to find the registry URI<br><br>The Azure container registry URI should have the following format:<br><br><REGISTRY_NAME>.azurecr.io<br><br># Examples:<br><br>zenmlregistry.azurecr.io<br><br>myregistry.azurecr.io<br><br>To figure out the URI for your registry:<br><br>Go to the Azure portal.<br><br>In the search bar, enter container registries and select the container registry you want to use. If you don't have any container registries yet, check out the deployment section on how to create one.<br><br>Use the name of your registry to fill the template <REGISTRY_NAME>.azurecr.io and get your URI.<br><br>How to use it<br><br>To use the Azure container registry, we need:<br><br>Docker installed and running.<br><br>The registry URI. Check out the previous section on the URI format and how to get the URI for your registry.<br><br>We can then register the container registry and use it in our active stack:<br><br>zenml container-registry register <NAME> \<br><br>--flavor=azure \<br><br>--uri=<REGISTRY_URI><br><br># Add the container registry to the active stack<br><br>zenml stack update -c <NAME><br><br>You also need to set up authentication required to log in to the container registry.<br><br>Authentication Methods</code>                             |
+  | <code>How can I create custom materializers in ZenML to handle specific serialization and deserialization logic?</code> | <code>s within a unique directory in the artifact store:Materializers are designed to be extensible and customizable, allowing you to define your own serialization and deserialization logic for specific data types or storage systems. By default, ZenML provides built-in materializers for common data types and uses cloudpickle to pickle objects where there is no default materializer. If you want direct control over how objects are serialized, you can easily create custom materializers by extending the BaseMaterializer class and implementing the required methods for your specific use case. Read more about materializers here.<br><br>ZenML provides a built-in CloudpickleMaterializer that can handle any object by saving it with cloudpickle. However, this is not production-ready because the resulting artifacts cannot be loaded when running with a different Python version. In such cases, you should consider building a custom Materializer to save your objects in a more robust and efficient format.<br><br>Moreover, using the CloudpickleMaterializer could allow users to upload of any kind of object. This could be exploited to upload a malicious file, which could execute arbitrary code on the vulnerable system.<br><br>When a pipeline runs, ZenML uses the appropriate materializers to save and load artifacts using the ZenML fileio system (built to work across multiple artifact stores). This not only simplifies the process of working with different data formats and storage systems but also enables artifact caching and lineage tracking. You can see an example of a default materializer (the numpy materializer) in action here.<br><br>PreviousHandle Data/Artifacts<br><br>NextReturn multiple outputs from a step<br><br>Last updated 15 days ago</code>                                                                                                                                                                                                            |
+* Loss: [<code>MatryoshkaLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#matryoshkaloss) with these parameters:
+  ```json
+  {
+      "loss": "MultipleNegativesRankingLoss",
+      "matryoshka_dims": [
+          384,
+          256,
+          128,
+          64
+      ],
+      "matryoshka_weights": [
+          1,
+          1,
+          1,
+          1
+      ],
+      "n_dims_per_step": -1
+  }
+  ```
+
+### Training Hyperparameters
+#### Non-Default Hyperparameters
+
+- `eval_strategy`: epoch
+- `per_device_train_batch_size`: 32
+- `per_device_eval_batch_size`: 16
+- `gradient_accumulation_steps`: 16
+- `learning_rate`: 2e-05
+- `num_train_epochs`: 4
+- `lr_scheduler_type`: cosine
+- `warmup_ratio`: 0.1
+- `bf16`: True
+- `tf32`: True
+- `load_best_model_at_end`: True
+- `optim`: adamw_torch_fused
+- `batch_sampler`: no_duplicates
+
+#### All Hyperparameters
+<details><summary>Click to expand</summary>
+
+- `overwrite_output_dir`: False
+- `do_predict`: False
+- `eval_strategy`: epoch
+- `prediction_loss_only`: True
+- `per_device_train_batch_size`: 32
+- `per_device_eval_batch_size`: 16
+- `per_gpu_train_batch_size`: None
+- `per_gpu_eval_batch_size`: None
+- `gradient_accumulation_steps`: 16
+- `eval_accumulation_steps`: None
+- `learning_rate`: 2e-05
+- `weight_decay`: 0.0
+- `adam_beta1`: 0.9
+- `adam_beta2`: 0.999
+- `adam_epsilon`: 1e-08
+- `max_grad_norm`: 1.0
+- `num_train_epochs`: 4
+- `max_steps`: -1
+- `lr_scheduler_type`: cosine
+- `lr_scheduler_kwargs`: {}
+- `warmup_ratio`: 0.1
+- `warmup_steps`: 0
+- `log_level`: passive
+- `log_level_replica`: warning
+- `log_on_each_node`: True
+- `logging_nan_inf_filter`: True
+- `save_safetensors`: True
+- `save_on_each_node`: False
+- `save_only_model`: False
+- `restore_callback_states_from_checkpoint`: False
+- `no_cuda`: False
+- `use_cpu`: False
+- `use_mps_device`: False
+- `seed`: 42
+- `data_seed`: None
+- `jit_mode_eval`: False
+- `use_ipex`: False
+- `bf16`: True
+- `fp16`: False
+- `fp16_opt_level`: O1
+- `half_precision_backend`: auto
+- `bf16_full_eval`: False
+- `fp16_full_eval`: False
+- `tf32`: True
+- `local_rank`: 0
+- `ddp_backend`: None
+- `tpu_num_cores`: None
+- `tpu_metrics_debug`: False
+- `debug`: []
+- `dataloader_drop_last`: False
+- `dataloader_num_workers`: 0
+- `dataloader_prefetch_factor`: None
+- `past_index`: -1
+- `disable_tqdm`: True
+- `remove_unused_columns`: True
+- `label_names`: None
+- `load_best_model_at_end`: True
+- `ignore_data_skip`: False
+- `fsdp`: []
+- `fsdp_min_num_params`: 0
+- `fsdp_config`: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
+- `fsdp_transformer_layer_cls_to_wrap`: None
+- `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
+- `deepspeed`: None
+- `label_smoothing_factor`: 0.0
+- `optim`: adamw_torch_fused
+- `optim_args`: None
+- `adafactor`: False
+- `group_by_length`: False
+- `length_column_name`: length
+- `ddp_find_unused_parameters`: None
+- `ddp_bucket_cap_mb`: None
+- `ddp_broadcast_buffers`: False
+- `dataloader_pin_memory`: True
+- `dataloader_persistent_workers`: False
+- `skip_memory_metrics`: True
+- `use_legacy_prediction_loop`: False
+- `push_to_hub`: False
+- `resume_from_checkpoint`: None
+- `hub_model_id`: None
+- `hub_strategy`: every_save
+- `hub_private_repo`: False
+- `hub_always_push`: False
+- `gradient_checkpointing`: False
+- `gradient_checkpointing_kwargs`: None
+- `include_inputs_for_metrics`: False
+- `eval_do_concat_batches`: True
+- `fp16_backend`: auto
+- `push_to_hub_model_id`: None
+- `push_to_hub_organization`: None
+- `mp_parameters`: 
+- `auto_find_batch_size`: False
+- `full_determinism`: False
+- `torchdynamo`: None
+- `ray_scope`: last
+- `ddp_timeout`: 1800
+- `torch_compile`: False
+- `torch_compile_backend`: None
+- `torch_compile_mode`: None
+- `dispatch_batches`: None
+- `split_batches`: None
+- `include_tokens_per_second`: False
+- `include_num_input_tokens_seen`: False
+- `neftune_noise_alpha`: None
+- `optim_target_modules`: None
+- `batch_eval_metrics`: False
+- `batch_sampler`: no_duplicates
+- `multi_dataset_batch_sampler`: proportional
+
+</details>
+
+### Training Logs
+| Epoch      | Step  | dim_128_cosine_map@100 | dim_256_cosine_map@100 | dim_384_cosine_map@100 | dim_64_cosine_map@100 |
+|:----------:|:-----:|:----------------------:|:----------------------:|:----------------------:|:---------------------:|
+| 0.6667     | 1     | 0.4136                 | 0.4596                 | 0.4702                 | 0.3613                |
+| 2.0        | 3     | 0.4385                 | 0.4910                 | 0.4922                 | 0.3873                |
+| **2.6667** | **4** | **0.4483**             | **0.4929**             | **0.4931**             | **0.3936**            |
+
+* The bold row denotes the saved checkpoint.
+
+### Framework Versions
+- Python: 3.10.14
+- Sentence Transformers: 3.0.1
+- Transformers: 4.41.2
+- PyTorch: 2.3.1+cu121
+- Accelerate: 0.31.0
+- Datasets: 2.19.1
+- Tokenizers: 0.19.1
+
+## Citation
+
+### BibTeX
+
+#### Sentence Transformers
+```bibtex
+@inproceedings{reimers-2019-sentence-bert,
+    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
+    author = "Reimers, Nils and Gurevych, Iryna",
+    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
+    month = "11",
+    year = "2019",
+    publisher = "Association for Computational Linguistics",
+    url = "https://arxiv.org/abs/1908.10084",
+}
+```
+
+#### MatryoshkaLoss
+```bibtex
+@misc{kusupati2024matryoshka,
+    title={Matryoshka Representation Learning}, 
+    author={Aditya Kusupati and Gantavya Bhatt and Aniket Rege and Matthew Wallingford and Aditya Sinha and Vivek Ramanujan and William Howard-Snyder and Kaifeng Chen and Sham Kakade and Prateek Jain and Ali Farhadi},
+    year={2024},
+    eprint={2205.13147},
+    archivePrefix={arXiv},
+    primaryClass={cs.LG}
+}
+```
+
+#### MultipleNegativesRankingLoss
+```bibtex
+@misc{henderson2017efficient,
+    title={Efficient Natural Language Response Suggestion for Smart Reply}, 
+    author={Matthew Henderson and Rami Al-Rfou and Brian Strope and Yun-hsuan Sung and Laszlo Lukacs and Ruiqi Guo and Sanjiv Kumar and Balint Miklos and Ray Kurzweil},
+    year={2017},
+    eprint={1705.00652},
+    archivePrefix={arXiv},
+    primaryClass={cs.CL}
+}
+```
+
+<!--
+## Glossary
+
+*Clearly define terms in order to be accessible across audiences.*
+-->
+
+<!--
+## Model Card Authors
+
+*Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction.*
+-->
+
+<!--
+## Model Card Contact
+
+*Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors.*
+-->

config.json

@@ -0,0 +1,26 @@
+{
+  "_name_or_path": "sentence-transformers/all-MiniLM-L6-v2",
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "float32",
+  "transformers_version": "4.41.2",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

config_sentence_transformers.json

@@ -0,0 +1,10 @@
+{
+  "__version__": {
+    "sentence_transformers": "3.0.1",
+    "transformers": "4.41.2",
+    "pytorch": "2.3.1+cu121"
+  },
+  "prompts": {},
+  "default_prompt_name": null,
+  "similarity_fn_name": null
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d51cb2eb22028b3cd2bff6e6148b927a430ed64a2ac19b856425535081b6177
+size 90864192

modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+  "max_seq_length": 256,
+  "do_lower_case": false
+}

special_tokens_map.json

@@ -0,0 +1,37 @@
+{
+  "cls_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "[MASK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "[PAD]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "[SEP]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "[UNK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer_config.json

@@ -0,0 +1,64 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "max_length": 128,
+  "model_max_length": 256,
+  "never_split": null,
+  "pad_to_multiple_of": null,
+  "pad_token": "[PAD]",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "[SEP]",
+  "stride": 0,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "[UNK]"
+}