Ejemplo n.º 1
0
def xgboost_model():
    resource_name = random_suffix_name("xgboost-model", 32)

    replacements = REPLACEMENT_VALUES.copy()
    replacements["MODEL_NAME"] = resource_name

    model = load_resource_file(SERVICE_NAME,
                               "xgboost_model",
                               additional_replacements=replacements)
    logging.debug(model)

    # Create the k8s resource
    reference = k8s.CustomResourceReference(CRD_GROUP,
                                            CRD_VERSION,
                                            RESOURCE_PLURAL,
                                            resource_name,
                                            namespace="default")
    resource = k8s.create_custom_resource(reference, model)
    resource = k8s.wait_resource_consumed_by_controller(reference)

    assert resource is not None

    yield (reference, resource)

    # Delete the k8s resource if not already deleted by tests
    try:
        k8s.delete_custom_resource(reference)
    except:
        pass
def kmeans_processing_job():
    resource_name = random_suffix_name("kmeans-processingjob", 32)

    replacements = REPLACEMENT_VALUES.copy()
    replacements["PROCESSING_JOB_NAME"] = resource_name

    processing_job = load_resource_file(SERVICE_NAME,
                                        "kmeans_processingjob",
                                        additional_replacements=replacements)
    logging.debug(processing_job)

    # Create the k8s resource
    reference = k8s.CustomResourceReference(CRD_GROUP,
                                            CRD_VERSION,
                                            RESOURCE_PLURAL,
                                            resource_name,
                                            namespace="default")
    resource = k8s.create_custom_resource(reference, processing_job)
    resource = k8s.wait_resource_consumed_by_controller(reference)

    assert resource is not None

    yield (reference, resource)

    # Delete the k8s resource if not already deleted by tests
    try:
        k8s.delete_custom_resource(reference)
    except:
        pass
def xgboost_transformjob(sagemaker_client):
    #Create model using boto3 for TransformJob
    transform_model_file = "s3://{d}/sagemaker/batch/model.tar.gz".format(
        d=get_bootstrap_resources().DataBucketName)
    model_name = random_suffix_name("xgboost-model", 32)

    create_response = sagemaker_client.create_model(
        ModelName=model_name,
        PrimaryContainer={
            'Image': REPLACEMENT_VALUES["XGBOOST_IMAGE_URI"],
            'ModelDataUrl': transform_model_file,
            'Environment': {}
        },
        ExecutionRoleArn=REPLACEMENT_VALUES["SAGEMAKER_EXECUTION_ROLE_ARN"])
    logging.debug(create_response)

    #Check if the model is created successfully
    describe_model_response = sagemaker_client.describe_model(
        ModelName=model_name)
    assert describe_model_response["ModelName"] is not None

    resource_name = random_suffix_name("xgboost-transformjob", 32)

    #Use the model created above
    replacements = REPLACEMENT_VALUES.copy()
    replacements["MODEL_NAME"] = model_name
    replacements["TRANSFORM_JOB_NAME"] = resource_name

    transformjob = load_resource_file(SERVICE_NAME,
                                      "xgboost_transformjob",
                                      additional_replacements=replacements)
    logging.debug(transformjob)

    # Create the k8s resource
    reference = k8s.CustomResourceReference(CRD_GROUP,
                                            CRD_VERSION,
                                            RESOURCE_PLURAL,
                                            resource_name,
                                            namespace="default")
    resource = k8s.create_custom_resource(reference, transformjob)
    resource = k8s.wait_resource_consumed_by_controller(reference)

    assert resource is not None

    yield (reference, resource)

    try:
        # Delete the k8s resource if not already deleted by tests
        k8s.delete_custom_resource(reference)
    except:
        pass

    try:
        # Delete the model created
        sagemaker_client.delete_model(ModelName=model_name)
    except:
        pass
Ejemplo n.º 4
0
def single_variant_config():
    config_resource_name = random_suffix_name("single-variant-config", 32)
    model_resource_name = config_resource_name + "-model"

    replacements = REPLACEMENT_VALUES.copy()
    replacements["CONFIG_NAME"] = config_resource_name
    replacements["MODEL_NAME"] = model_resource_name

    model = load_resource_file(SERVICE_NAME,
                               "xgboost_model",
                               additional_replacements=replacements)
    logging.debug(model)

    config = load_resource_file(
        SERVICE_NAME,
        "endpoint_config_single_variant",
        additional_replacements=replacements,
    )
    logging.debug(config)

    # Create the k8s resources
    model_reference = k8s.CustomResourceReference(
        CRD_GROUP,
        CRD_VERSION,
        MODEL_RESOURCE_PLURAL,
        model_resource_name,
        namespace="default",
    )
    model_resource = k8s.create_custom_resource(model_reference, model)
    model_resource = k8s.wait_resource_consumed_by_controller(model_reference)
    assert model_resource is not None

    config_reference = k8s.CustomResourceReference(
        CRD_GROUP,
        CRD_VERSION,
        CONFIG_RESOURCE_PLURAL,
        config_resource_name,
        namespace="default",
    )
    config_resource = k8s.create_custom_resource(config_reference, config)
    config_resource = k8s.wait_resource_consumed_by_controller(
        config_reference)
    assert config_resource is not None

    yield (config_reference, config_resource)

    # Delete the k8s resource if not already deleted by tests
    try:
        k8s.delete_custom_resource(model_reference)
        k8s.delete_custom_resource(config_reference)
    except:
        pass
Ejemplo n.º 5
0
def _make_hpojob():
    resource_name = random_suffix_name("xgboost-hpojob", 32)

    replacements = REPLACEMENT_VALUES.copy()
    replacements["HPO_JOB_NAME"] = resource_name

    data = load_resource_file(SERVICE_NAME,
                              "xgboost_hpojob",
                              additional_replacements=replacements)
    logging.debug(data)

    reference = k8s.CustomResourceReference(CRD_GROUP,
                                            CRD_VERSION,
                                            RESOURCE_PLURAL,
                                            resource_name,
                                            namespace="default")

    return reference, data
def xgboost_trainingjob():
    resource_name = random_suffix_name("xgboost-trainingjob", 32)

    replacements = REPLACEMENT_VALUES.copy()
    replacements["TRAINING_JOB_NAME"] = resource_name

    trainingjob = load_resource_file(SERVICE_NAME,
                                     "xgboost_trainingjob",
                                     additional_replacements=replacements)
    logging.debug(trainingjob)

    # Create the k8s resource
    reference = k8s.CustomResourceReference(CRD_GROUP,
                                            CRD_VERSION,
                                            RESOURCE_PLURAL,
                                            resource_name,
                                            namespace="default")
    resource = k8s.create_custom_resource(reference, trainingjob)
    resource = k8s.wait_resource_consumed_by_controller(reference)

    assert resource is not None

    yield (reference, resource)
Ejemplo n.º 7
0
def single_variant_xgboost_endpoint():
    endpoint_resource_name = random_suffix_name("single-variant-endpoint", 32)
    config1_resource_name = endpoint_resource_name + "-config"
    model_resource_name = config1_resource_name + "-model"

    replacements = REPLACEMENT_VALUES.copy()
    replacements["ENDPOINT_NAME"] = endpoint_resource_name
    replacements["CONFIG_NAME"] = config1_resource_name
    replacements["MODEL_NAME"] = model_resource_name

    model = load_resource_file(
        SERVICE_NAME, "xgboost_model", additional_replacements=replacements
    )
    logging.debug(model)

    config = load_resource_file(
        SERVICE_NAME,
        "endpoint_config_single_variant",
        additional_replacements=replacements,
    )
    logging.debug(config)

    endpoint_spec = load_resource_file(
        SERVICE_NAME, "endpoint_base", additional_replacements=replacements
    )
    logging.debug(endpoint_spec)

    # Create the k8s resources
    model_reference = k8s.CustomResourceReference(
        CRD_GROUP,
        CRD_VERSION,
        MODEL_RESOURCE_PLURAL,
        model_resource_name,
        namespace="default",
    )
    model_resource = k8s.create_custom_resource(model_reference, model)
    model_resource = k8s.wait_resource_consumed_by_controller(model_reference)
    assert model_resource is not None

    config1_reference = k8s.CustomResourceReference(
        CRD_GROUP,
        CRD_VERSION,
        CONFIG_RESOURCE_PLURAL,
        config1_resource_name,
        namespace="default",
    )
    config1_resource = k8s.create_custom_resource(config1_reference, config)
    config1_resource = k8s.wait_resource_consumed_by_controller(config1_reference)
    assert config1_resource is not None

    config2_resource_name = random_suffix_name("2-single-variant-endpoint", 32)
    config["metadata"]["name"] = config["spec"][
        "endpointConfigName"
    ] = config2_resource_name
    logging.debug(config)
    config2_reference = k8s.CustomResourceReference(
        CRD_GROUP,
        CRD_VERSION,
        CONFIG_RESOURCE_PLURAL,
        config2_resource_name,
        namespace="default",
    )
    config2_resource = k8s.create_custom_resource(config2_reference, config)
    config2_resource = k8s.wait_resource_consumed_by_controller(config2_reference)
    assert config2_resource is not None

    endpoint_reference = k8s.CustomResourceReference(
        CRD_GROUP,
        CRD_VERSION,
        ENDPOINT_RESOURCE_PLURAL,
        endpoint_resource_name,
        namespace="default",
    )
    endpoint_resource = k8s.create_custom_resource(endpoint_reference, endpoint_spec)
    endpoint_resource = k8s.wait_resource_consumed_by_controller(endpoint_reference)
    assert endpoint_resource is not None

    yield (endpoint_reference, endpoint_resource, endpoint_spec, config2_resource_name)

    # Delete the k8s resource if not already deleted by tests
    for cr in (model_reference, config1_reference, config2_reference, endpoint_reference):
        try:
            k8s.delete_custom_resource(cr)
        except:
            pass