<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Michael Jones on Medium]]></title>
        <description><![CDATA[Stories by Michael Jones on Medium]]></description>
        <link>https://medium.com/@michael.jones4_46558?source=rss-32263dba2104------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*5QbXfp0jk_V58X9hqETV-A.png</url>
            <title>Stories by Michael Jones on Medium</title>
            <link>https://medium.com/@michael.jones4_46558?source=rss-32263dba2104------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 19:30:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@michael.jones4_46558/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Vertex AI Pipelines: Notebooks in Disguise]]></title>
            <link>https://medium.com/kingfisher-technology/vertex-ai-pipelines-notebooks-in-disguise-d5956ff0434?source=rss-32263dba2104------2</link>
            <guid isPermaLink="false">https://medium.com/p/d5956ff0434</guid>
            <category><![CDATA[vertex-ai]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[kubeflow-pipelines]]></category>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Michael Jones]]></dc:creator>
            <pubDate>Thu, 16 Mar 2023 18:02:18 GMT</pubDate>
            <atom:updated>2023-11-08T08:57:17.077Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ebVsPAYL6PbPky-VDPo2Sg.png" /><figcaption>With pytest, we can mock the inputs and outputs of a Kubeflow Pipeline, and ignore the rest of the pipeline when developing our components</figcaption></figure><p>Whenever I start off a new data science project my first port of call is always a <a href="https://jupyter.org/">jupyter notebook</a>. It allows me to quickly get to the problem’s pain point and, once found, I can quickly iterate on a solution because the intermediate results are instantly available. When I’m happy, I can move off in search of the next problem. It’s great.</p><p>But what about when I want to share my solution with the rest of Group Data Science? What about when I want to deploy my solution to production? What about when I have to move on to the next project, only to return in a few weeks or months to find a mess of essentially useless code?</p><p>To address these problems in Kingfisher Group Data Science we’ve used Google’s <a href="https://www.kubeflow.org/docs/pipelines/overview/pipelines-overview/">Kubeflow Pipeline’s</a> <a href="https://www.kubeflow.org/docs/components/pipelines/v1/sdk-v2/v2-compatibility/">SDK v2</a>, which we deploy using the fantastic <a href="https://cloud.google.com/vertex-ai/docs/pipelines/introduction">Vertex AI Pipelines</a>.</p><p>Kubeflow Pipelines map neatly onto the style of working we’re used to in notebooks. Each operation you want to carry out is wrapped up as a component, and can be thought of similar to a cell in a notebook. The input <a href="https://www.kubeflow.org/docs/components/pipelines/v2/author-a-pipeline/component-io/">artifacts</a>¹ are read from storage and once the operation is complete the outputs are written back to storage, in much the same way that the notebook’s outputs are saved to variables within the notebook environment. Each of these components can be chained together to form a <a href="https://en.wikipedia.org/wiki/Directed_acyclic_graph">DAG</a>, which is then executed in the same way you can execute cells one after another in a notebook. But instead of a notebook cell trapped in the same environment, chained to the same hardware, pipeline components are run on a kubernetes cluster. That means when you come to production you can provide the expensive compute to only those processes which need it.</p><p>During development, spinning up a kubernetes cluster every time you want a trial run of a single cell of a notebook would be overkill. With only a small amount of setup, however, you can have all the benefits of the research cycle which comes from working in notebooks, whilst actually writing code which can easily be shared, reviewed, and deployed. And, the best thing is, the set-up <em>requires tests</em>.</p><h3>Tests? That’s not very notebook-y</h3><p>Maybe not, but to enable the quick iterative development cycle we’re used to, we need to be able to run only small sections of our code whilst saving the intermediate results. In the production environment that’s handled by Vertex AI Pipelines, but in our development environment we want to be able to run our code locally. The 30 second wait time for a pipeline to be uploaded and run is not conducive to a quick iterative cycle.</p><p>Unfortunately, the .python_func member of a Kubeflow Pipeline component still requires you to pass in <a href="https://www.kubeflow.org/docs/components/pipelines/v2/author-a-pipeline/component-io/">Artifacts</a> as arguments - and the artifact classes require a cloud storage URI. So we can&#39;t just pass in a pandas dataframe, we have to pass in a Dataset artifact with a URI pointing to a file containing the data. But all is not lost! Instead of worrying about cloud storage we can use <a href="https://docs.pytest.org/en/6.2.x/">pytest</a> fixtures to mock the Kubeflow Artifacts, an approach originally outlined in <a href="https://stackoverflow.com/a/74190487/5838018">this stack overflow post</a>.</p><pre>import typing<br><br>def make_test_artifact(artifact_type):<br>    class TestArtifact(artifact_type):  # type: ignore<br>        def _get_path(self):<br>            return super()._get_path() or self.uri<br>    return TestArtifact</pre><p>Using the make_test_artifact class factory we can create a fixture which returns a Dataset artifact with a uri pointing to a file in a temporary directory containing some input data:</p><pre>import pytest<br>from kfp.v2.dsl import Dataset<br>import pandas as pd<br><br>@pytest.fixture(scope=&#39;session&#39;, name=&#39;input_data&#39;)<br>def input_dataset_artifact(tmp_path_factory):<br>    temp_dir = tmp_path_factory.mktemp(&#39;artifact_store&#39;)<br>    uri = str(temp_dir / &#39;input.csv&#39;)<br>    pd.write_csv(uri, data={&#39;text&#39;: [&#39;Hello world&#39;, &#39;Goodbye world&#39;]})<br>    output_dataset = make_test_artifact(Dataset)(uri=uri)<br>    return output_dataset</pre><p>and an output artifact fixture to contain the output of our component:</p><pre>@pytest.fixture(scope=&#39;session&#39;, name=&#39;output_data&#39;)<br>def output_dataset_artifact(tmp_path_factory):<br>    temp_dir = tmp_path_factory.mktemp(&#39;artifact_store&#39;)<br>    uri = str(temp_dir / &#39;output.csv&#39;)<br>    output_dataset = make_test_artifact(Dataset)(uri=uri)<br>    return output_dataset</pre><p>The python code for our component is described in a function which takes the input and output artifacts as arguments and performs some data science-y stuff:</p><pre>from kfp.v2.dsl import Dataset, Output, Input, component, Model<br><br>@component(<br>    packages_to_install=[<br>        &quot;pandas==1.3.4&quot;,<br>        &quot;numpy==1.23.2&quot;,<br>    ],<br>    base_image=&quot;python:3.10.5-slim-bullseye&quot;<br>)<br>def clean_text_data(<br>    input_art: Input[Dataset],<br>    output_art: Output[Dataset]<br>) -&gt; None:<br>    import pandas as pd<br>    import numpy as np<br><br>    df = pd.read_csv(input_art.path)<br><br>    df[&#39;text&#39;] = df[&#39;text&#39;].str.lower()<br>    df[&#39;text&#39;] = df[&#39;text&#39;].str.replace(&#39;[^\w\s]&#39;,&#39;&#39;)<br>    df[&#39;text&#39;] = df[&#39;text&#39;].str.replace(&#39;\d+&#39;, &#39;&#39;)<br>    df[&#39;text&#39;] = df[&#39;text&#39;].str.replace(&#39;\s+&#39;, &#39; &#39;)<br>    df[&#39;text&#39;] = df[&#39;text&#39;].str.strip()<br><br>    df.to_csv(output_art.path, index=False)</pre><p>which we then ‘test’ using the fixtures we created earlier, accessing the python function directly using the component’s .python_func member:</p><pre>def test__clean_text_data__cleans_text_data(input_data, output_data):<br>    clean_text_data.python_func(<br>        input_art=input_data, output_art=output_data)<br>    df = pd.read_csv(output_data.path)<br>    assert df[&#39;text&#39;].str.contains(&#39;hello world&#39;).all()<br>    assert df[&#39;text&#39;].str.contains(&#39;goodbye world&#39;).all()</pre><h3>Whats so notebook-y about that? Are you just trying to make me write tests?</h3><p>Yes. Yes I am.</p><p>But by altering the pytest fixtures we can change from an <a href="https://en.wikipedia.org/wiki/Idempotence">idempotent</a> test to a notebook-like environment.</p><pre>import os<br>import pytest<br>from kfp.v2.dsl import Dataset<br>import pandas as pd<br><br>@pytest.fixture(scope=&#39;session&#39;, name=&#39;input_data&#39;)<br>def input_dataset_artifact(tmp_path_factory):<br>    os.path.exists(&#39;artifact_store&#39;) or os.mkdir(&#39;artifact_store&#39;)<br>    uri = os.path.join(&#39;artifact_store&#39;, &#39;input.csv&#39;)<br>    pd.write_csv(uri, data={&#39;text&#39;: [&#39;Hello world&#39;, &#39;Goodbye world&#39;]})<br>    output_dataset = make_test_artifact(Dataset)(uri=uri)<br>    return output_dataset<br><br>@pytest.fixture(scope=&#39;session&#39;, name=&#39;output_data&#39;)<br>def output_dataset_artifact(tmp_path_factory):<br>    os.path.exists(&#39;artifact_store&#39;) or os.mkdir(&#39;artifact_store&#39;)<br>    uri = os.path.join(&#39;artifact_store&#39;, &#39;output.csv&#39;)<br>    output_dataset = make_test_artifact(Dataset)(uri=uri)<br>    return output_dataset</pre><p>Although constructing fixtures this way is not suitable when writing tests, we’re not writing tests anymore! We’re using pytest fixtures to allow us to run our Kubeflow components locally in a development environment. Now, we can run our “tests” and then open the output file to inspect the results. We can also use those outputs in the next component by using the output_dataset_artifact as an input. Finally, when we do come to want tested code, we must return our fixtures to idempotence by saving the artifacts to a temporary directory again.</p><p>We can go one step further and just run the component directly in the notebook by changing those fixtures to functions which return the contents of the file instead of the artifact. That might seem like a lot of effort for a notebook, but it means that we can run the same code in the notebook and in the final pipeline without having to change anything.</p><p>Generating all these fixtures can lead to your code being littered with boilerplate, so we can wrap all that logic in an function which examines the signature of your component and generates the required mocks for you.</p><p>First we need to update and expand the make_test_artifact:</p><pre>from typing import Callable, Type, TypeVar, Optional, Union, Any, get_args<br>from dataclasses import dataclass<br>from os.path import join<br>from pathlib import Path<br>import inspect<br>import pytest<br><br>from shared_components.kfp_versioning import Artifact<br><br>ArtifactT = TypeVar(&quot;ArtifactT&quot;, bound=Artifact)<br>ArtifactFactory = Callable[[Type[ArtifactT]], Type[ArtifactT]]<br>Adapter = Callable[[Callable], Callable]<br><br>FilePath = Union[str, Path]<br><br>def make_test_artifact(artifact_type: Type[ArtifactT]) -&gt; Type[ArtifactT]:<br>    &quot;&quot;&quot;Generated test artifacts for use in testing. The default aritfact types<br>    requre the URIs to be formatted as gcs/s3 uris - otherwise returns None.<br><br>    Args:<br>        artifact_type (typing.Type): The type of artifact to be generated<br><br>    Returns:<br>        TestArtifact: Version of artifact_type which can be used to test<br>        the .python_func member of kfpl python components<br>    &quot;&quot;&quot;<br><br>    class TestArtifact(artifact_type):  # type: ignore # pylint: disable=too-few-public-methods<br>        # `__init__` is added to allow using also Path object to construct a test artifact.<br>        def __init__(self, uri: Optional[FilePath] = None) -&gt; None:<br>            super().__init__(uri=str(uri) if uri else uri)<br><br>        def _get_path(self):<br>            return super()._get_path() or self.uri<br><br>    return TestArtifact</pre><p>And define a dataclass to use as the output of our kubeflow components:</p><pre>@dataclass<br>class _ComponentOutput:<br>    &quot;&quot;&quot;Class for mocking the returned value of a component function.<br><br>    Attributes:<br>        output (Any): Holds the returned value of python_func, which is used when a basic type is returned.<br>        outputs (dict): A dictionary of outputs.  This is used when a NamedTuple is returned.<br>            It is also used to hold the Output artifacts.<br>    &quot;&quot;&quot;<br><br>    output: Any<br>    outputs: dict[str, Any]<br><br>    def set_display_name(self, *_, **__):<br>        return self<br><br>    def set_caching_options(self, *_, **__):<br>        return self<br></pre><p>We can the define our run component function which generates the artifacts based on the signiture of the component.</p><pre>def run_component(<br>    tmp_path_factory,<br>    component_def,<br>    artifact_factory: ArtifactFactory = make_test_artifact,<br>    **kwargs,<br>) -&gt; _ComponentOutput:<br>    &quot;&quot;&quot;Function automatically generate mock artifacts for a test from a component definition.<br><br>    It checks for any Artifact in the component function signature and looks for a given<br>    artifact from the `kwargs`.  If only a string is given, it will be used as the uri<br>    for the artifact generated by `artifact_factory` (which defaults to `make_test_artifact`)<br>    If nothing is provided for this artifact, it will use the name of the<br>    artifact as the uri and store it in a temporary directory. You must pass the tmp_path_factory<br>    fixture to this function to allow it to generate the temporary directory safely using pytest logic.<br><br>    It then calls the component&#39;s python_func with the generated artifacts and any other kwargs.<br><br>    The object returned contains two properties `output` and `outputs`, that can be used similarly as<br>    the output of a component in a pipeline.<br>    The given or generated artifacts are contained in the `outputs`, allowing the test to run assertions<br>    on their contents.<br><br>    The artifact_factory is used to create test artifacts.  A non-default version can be given<br>    if different types of mock artifacts need to be created.<br><br>    Examples:<br>    ```python<br>    @component(...)<br>    def detect_softmax_bias(predictions_art: Input[Dataset], output_art: Output[Dataset], threshold)<br>        ...<br><br>    def test_detect_softmax_bias(tmp_path_factory):<br>        result = run_component(tmp_path_factory, detect_softmax_bias, predictions_art=&#39;foo.npy&#39;, threshold=0.9)<br>        assert filecmp(result.outputs[&#39;output_art&#39;].path, &#39;foo.csv&#39;)<br>    ```<br>    &quot;&quot;&quot;<br><br>    artifacts = {}<br>    other_args = {}<br><br>    sig = inspect.signature(component_def.python_func)<br><br>    # check if all the given arguments exist in the function signature<br>    extra_arguments = kwargs.keys() - sig.parameters.keys()<br>    if extra_arguments:<br>        raise ValueError(f&quot;kwargs contains arguments not found in the component function signature: {extra_arguments}&quot;)<br><br>    for name, param in sig.parameters.items():<br>        # Check only if the annontation represents a class<br>        if any(issubclass(ann, Artifact) for ann in get_args(param.annotation) if inspect.isclass(ann)):<br>            value = kwargs.get(name, join(tmp_path_factory.mktemp(&quot;artifact_store&quot;), name))<br>            # ignore type check because parameterized generics cannot be handled properly<br>            if isinstance(value, FilePath):  # type: ignore<br>                # create an artifact if it is a file path<br>                artifacts[name] = artifact_factory(param.annotation)(value)<br>            else:<br>                # assume the given value is the artifact<br>                artifacts[name] = value<br><br>            continue<br><br>        # Only pass along the argument when it is given.<br>        # This is important for parameters with default values as<br>        # arguments may not be given in that case (i.e. name not in kwargs).<br>        if name in kwargs:<br>            other_args[name] = kwargs.get(name)<br><br>    res = component_def.python_func(**artifacts, **other_args)<br><br>    # include the Output artifacts in the outputs (but this includes also the Input ones)<br>    outputs = artifacts<br><br>    # If the component function returns a NamedTuple, add those elements to the outputs dict.<br>    # As there is no simple way to test whether an object is a subclass of NamedTuple,<br>    # we restort to testing one of the characteristics of NamedTuple,<br>    # which may also be True for some other classes.<br>    # For a more specific way to test, see https://stackoverflow.com/a/2166841.<br>    if hasattr(res, &quot;_asdict&quot;):<br>        outputs = outputs | res._asdict()<br><br>    # the artifacts include those marked Input as well as Output<br>    return _ComponentOutput(output=res, outputs=outputs)</pre><p>And an adapter fixture which wraps a component to make it operate like a regular python function:</p><pre>def make_component_adapter_fixture(<br>    artifact_factory: ArtifactFactory = make_test_artifact,<br>) -&gt; Callable[..., Adapter]:<br>    &quot;&quot;&quot;Make a fixture that can be used to adapt component for being called as a typical function with `run_component`.<br><br>    Args:<br>        artifact_factory (ArtifactFactory): function to create a artifact based on a given `Artifact` type.<br><br>    Returns:<br>        Callable: a adapter fixture<br><br>    Examples:<br>      ::<br>        # component definition<br>        @component<br>        def detect_softmax_bias(predictions_art: Input[Dataset], output_art: Output[Dataset], threshold):<br>            pass<br><br>        # create a adapter fixture in your test file or conftest.py<br>        local_component_adapter = make_component_adapter_fixture()<br><br>        # write a test (expecting the adapter fixture) in your test file<br>        def test_detect_softmax_bias(local_component_adapter):<br>            result = local_component_adapter(detect_softmax_bias)(predictions_art=&#39;foo.npy&#39;, threshold=0.9)<br>            assert filecmp(result.outputs[&#39;output_art&#39;].path, &#39;foo.csv&#39;)<br>    &quot;&quot;&quot;<br><br>    @pytest.fixture(scope=&quot;package&quot;)<br>    def adapter_fixture(tmp_path_factory) -&gt; Adapter:<br>        # This function binds the `tmp_path_factory` fixture and the given `artifact_factory` to the `run_component`.<br>        def adapt(component: Callable) -&gt; Callable:<br>            return lambda **kwargs: run_component(<br>                tmp_path_factory,<br>                component_def=component,<br>                artifact_factory=artifact_factory,<br>                **kwargs,<br>            )<br><br>        return adapt<br><br>    return adapter_fixture</pre><p>With the ability to easily run our pipeline components locally, we can start to think of how to take advantage of other huge benefits of Kubeflow Pipelines, one of which is the ability to share components between pipelines.</p><h3>Shared components</h3><p>Plenty of the cells in your notebook are reusable, and if you’re working in a team you’ve probably all got your own versions of these cells. When working with Pipelines that means Shared Components.</p><p>For example we have a shared component which reads data from the Kingfisher Databricks Data Lake and writes it to a .csv file. Everyone in the team needs this functionality, so we write it once and then import it into our pipelines:</p><pre>from kfp.v2.dsl import Dataset, Output, component<br><br>@component(<br>    packages_to_install=[&quot;pandas==1.4.3&quot;,<br>                         &quot;databricks-sql-connector==2.0.4&quot;],<br>    base_image=&quot;python:3.10.5-slim-bullseye&quot;<br>)<br>def extract_from_nucleus(<br>    query: str,<br>    dataset: Output[Dataset],<br>) -&gt; None:<br>    &quot;&quot;&quot;Extracts data from nucleus using the query provided and stores it as a csv<br><br>    Args:<br>        query (str): the sql query you are providing to extract the data<br>        dataset (Output[Dataset]): the output dataset<br>    &quot;&quot;&quot;<br>    import pandas as pd<br>    from databricks import sql<br><br>    # TODO: SECURITY<br><br>    with sql.connect(server_hostname=SERVER_HOSTNAME,<br>                     http_path=HTTP) as connection:<br>        with connection.cursor() as cursor:<br>            cursor.execute(query)<br>            result = [row.asDict() for row in cursor.fetchall()]<br><br>    output_df = pd.DataFrame(result)<br>    output_df.to_csv(dataset.path, index=False, encoding=&#39;utf-8-sig&#39;)</pre><p>Missing from this component is the security credentials to access the data lake, and the code for accessing those credentials. There are plenty of ways to do this but for AI Platform Pipelines Google’s <a href="https://cloud.google.com/vertex-ai/docs/pipelines/secret-manager">recommended strategy</a> is to use <a href="https://cloud.google.com/secret-manager">Secret Manager</a> to store the credentials and then use Service Accounts to allow the pipeline to access the credentials. Passing credentials as arguments into components is not recommended since the inputs and outputs of components are passed as plaintext!</p><p>In Kingfisher Group Data Science we enable the sharing of components by writing our pipelines as contributions to a <a href="https://en.wikipedia.org/wiki/Monorepo">monorepo</a>. It is also possible to host components as part of a pip package. Which is how the prebuilt components in <a href="https://google-cloud-pipeline-components.readthedocs.io/en/google-cloud-pipeline-components-1.0.39/">google cloud components</a> are available.</p><p>For example, we can use the <a href="https://google-cloud-pipeline-components.readthedocs.io/en/google-cloud-pipeline-components-0.1.6/google_cloud_pipeline_components.aiplatform.html#google_cloud_pipeline_components.aiplatform.ImageDatasetCreateOp">ImageDatasetCreateOp</a> from google cloud components to import image data from a GCS bucket into a dataset.</p><pre>from google_cloud_pipeline_components import aiplatform as gcc_aip<br><br>ds_op = gcc_aip.ImageDatasetCreateOp(<br>    project=project,<br>    display_name=&quot;flowers&quot;,<br>    gcs_source=&quot;gs://cloud-samples-data/vision/automl_classification/flowers/all_data_v2.csv&quot;,<br>    import_schema_uri=aip.schema.dataset.ioformat.image.single_label_classification,<br>)</pre><p>Where the import_schema_uri is the schema for the data we are importing - in this case describing the data as a single label classification problem where each row in all_data_v2.csv is the uri of a single image with a corresponding label.</p><p>The precompiled components do not have the .python_func attribute we used above to run the component locally. Instead we can write a function which wraps the op in a pipeline and executes the code locally:</p><pre>import kfp<br>from google_cloud_pipeline_components import aiplatform as gcc_aip<br>import google.cloud.aiplatform as aip<br><br>def run_locally(op):<br>    def wrapper(*args, **kwargs):<br>        @dsl.pipeline()<br>        def pipeline_wrapper():<br>            op(*args, **kwargs)<br>        kfp.run_pipeline_func_locally(pipeline_wrapper, arguments={})<br>    return wrapper<br><br>run_locally(gcc_aip.ImageDatasetCreateOp)(<br>    project=&#39;my-project&#39;,<br>    display_name=&quot;flowers&quot;,<br>    gcs_source=&quot;gs://cloud-samples-data/vision/automl_classification/flowers/all_data_v2.csv&quot;,<br>    import_schema_uri=aip.schema.dataset.ioformat.image.single_label_classification,<br>)</pre><p>Most of the time this will require docker to be installed, but it is a very useful tool for testing components locally. For SDK V2 components there is a third party <a href="https://github.com/lynnmatrix/kfp-local">local client</a>.</p><p>Kubeflow Pipelines with Vertex AI lets you enjoy the productivity and exploration benefits of notebooks, while providing a path to scalable, reviewable, and deployable production code. And if you’re worried about losing the rapid iteration cycle that makes notebooks so fun, fear not! You can write tests that run on your local machine and save the intermediate results as test artifacts, all while mocking out Kubeflow components using pytest fixtures.</p><p>So, what we’ve come to realise at Kingfisher is every time we’re tempted to create a jupyter notebook to prototype a data science project, we reach for Kubeflow Pipelines and Vertex AI instead.</p><p>If you are interested in joining us on our Data Science journey, please do check out our <a href="https://careers.kingfisher.com/">careers page</a>.</p><p>Thanks for reading</p><p>[1]<em> I have used the American spelling “artifact”, as opposed to “artefact”, throughout to keep consistent with Kubeflow.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d5956ff0434" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kingfisher-technology/vertex-ai-pipelines-notebooks-in-disguise-d5956ff0434">Vertex AI Pipelines: Notebooks in Disguise</a> was originally published in <a href="https://medium.com/kingfisher-technology">Kingfisher-Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>