Gépi tanulási folyamatok közzététele és nyomon követése
ÉRVÉNYES:Python SDK azureml v1
Ez a cikk bemutatja, hogyan oszthat meg gépi tanulási folyamatot munkatársaival vagy ügyfeleivel.
A gépi tanulási folyamatok újrafelhasználható munkafolyamatok a gépi tanulási feladatokhoz. A folyamatok egyik előnye a fokozott együttműködés. A folyamatokat verziószámozással is használhatja, így az ügyfelek használhatják az aktuális modellt, miközben új verzión dolgoznak.
Előfeltételek
Azure Machine Tanulás-munkaterület létrehozása az összes folyamaterőforrás tárolásához
A fejlesztési környezet konfigurálása az Azure Machine Tanulás SDK telepítéséhez, vagy azure machine Tanulás számítási példány használata a már telepített SDK-val
Hozzon létre és futtasson egy gépi tanulási folyamatot, például a következő oktatóanyagban: Azure Machine Tanulás-folyamat létrehozása kötegelt pontozáshoz. További lehetőségek: Gépi tanulási folyamatok létrehozása és futtatása az Azure Machine Tanulás SDK-val
Folyamat közzététele
Miután létrehozta és futtatta a folyamatot, közzétehet egy folyamatot, hogy az különböző bemenetekkel fusson. Ahhoz, hogy egy már közzétett folyamat REST-végpontja fogadja a paramétereket, konfigurálnia kell a folyamatot, hogy objektumokat használjon PipelineParameter
a változó argumentumokhoz.
Folyamatparaméter létrehozásához használjon egy PipelineParameter objektumot egy alapértelmezett értékkel.
from azureml.pipeline.core.graph import PipelineParameter pipeline_param = PipelineParameter( name="pipeline_arg", default_value=10)
Adja hozzá ezt az
PipelineParameter
objektumot paraméterként a folyamat bármely lépéséhez az alábbiak szerint:compareStep = PythonScriptStep( script_name="compare.py", arguments=["--comp_data1", comp_data1, "--comp_data2", comp_data2, "--output_data", out_data3, "--param1", pipeline_param], inputs=[ comp_data1, comp_data2], outputs=[out_data3], compute_target=compute_target, source_directory=project_folder)
Tegye közzé ezt a folyamatot, amely meghívásakor elfogad egy paramétert.
published_pipeline1 = pipeline_run1.publish_pipeline( name="My_Published_Pipeline", description="My Published Pipeline Description", version="1.0")
A folyamat közzététele után a felhasználói felületen ellenőrizheti. A folyamatazonosító a közzétett folyamat egyedi azonosítója.
Közzétett folyamat futtatása
Minden közzétett folyamat rendelkezik REST-végpontokkal. A folyamatvégponttal bármilyen külső rendszerből elindíthatja a folyamat futtatását, beleértve a nem Python-ügyfeleket is. Ez a végpont lehetővé teszi a "felügyelt ismételhetőséget" kötegelt pontozási és újratanítási forgatókönyvekben.
Fontos
Ha azure-beli szerepköralapú hozzáférés-vezérlést (Azure RBAC) használ a folyamathoz való hozzáférés kezeléséhez, állítsa be a folyamatforgatókönyv engedélyeit (betanítás vagy pontozás).
Az előző folyamat futtatásának meghívásához Microsoft Entra hitelesítési fejléc jogkivonatra van szükség. Az ilyen jogkivonatok lekérését az AzureCliAuthentication osztály referenciája és az Azure Machine-hitelesítés Tanulás jegyzetfüzet ismerteti.
from azureml.pipeline.core import PublishedPipeline
import requests
response = requests.post(published_pipeline1.endpoint,
headers=aad_token,
json={"ExperimentName": "My_Pipeline",
"ParameterAssignments": {"pipeline_arg": 20}})
A json
POST-kérelem argumentumának tartalmaznia kell a ParameterAssignments
kulcshoz a folyamatparamétereket és azok értékeit tartalmazó szótárt. Az argumentum emellett a json
következő kulcsokat is tartalmazhatja:
Key | Leírás |
---|---|
ExperimentName |
A végponthoz társított kísérlet neve |
Description |
A végpontot leíró szabadkéű szöveg |
Tags |
Szabadkézi kulcs-érték párok, amelyek a kérelmek címkézésére és széljegyzetelésére használhatók |
DataSetDefinitionValueAssignments |
Az adathalmazok újratanítás nélküli módosításához használt szótár (lásd az alábbi vitafórumot) |
DataPathAssignments |
A datapaths újratanítás nélküli módosításához használt szótár (lásd az alábbi vitafórumot) |
Közzétett folyamat futtatása a C használatával#
Az alábbi kód bemutatja, hogyan hívhat meg egy folyamatot aszinkron módon a C#-ból. A részleges kódrészlet csak a hívásstruktúrát jeleníti meg, és nem része a Microsoft-mintának. Nem jelenik meg teljes osztályok vagy hibakezelés.
[DataContract]
public class SubmitPipelineRunRequest
{
[DataMember]
public string ExperimentName { get; set; }
[DataMember]
public string Description { get; set; }
[DataMember(IsRequired = false)]
public IDictionary<string, string> ParameterAssignments { get; set; }
}
// ... in its own class and method ...
const string RestEndpoint = "your-pipeline-endpoint";
using (HttpClient client = new HttpClient())
{
var submitPipelineRunRequest = new SubmitPipelineRunRequest()
{
ExperimentName = "YourExperimentName",
Description = "Asynchronous C# REST api call",
ParameterAssignments = new Dictionary<string, string>
{
{
// Replace with your pipeline parameter keys and values
"your-pipeline-parameter", "default-value"
}
}
};
string auth_key = "your-auth-key";
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", auth_key);
// submit the job
var requestPayload = JsonConvert.SerializeObject(submitPipelineRunRequest);
var httpContent = new StringContent(requestPayload, Encoding.UTF8, "application/json");
var submitResponse = await client.PostAsync(RestEndpoint, httpContent).ConfigureAwait(false);
if (!submitResponse.IsSuccessStatusCode)
{
await WriteFailedResponse(submitResponse); // ... method not shown ...
return;
}
var result = await submitResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
var obj = JObject.Parse(result);
// ... use `obj` dictionary to access results
}
Közzétett folyamat futtatása Java használatával
Az alábbi kód egy hitelesítést igénylő folyamat hívását mutatja be (lásd: Az Azure Machine Tanulás erőforrások és munkafolyamatok hitelesítésének beállítása). Ha a folyamat nyilvánosan van üzembe helyezve, nincs szüksége azokat a hívásokat, amelyek létrehoznak authKey
. A részleges kódrészlet nem jeleníti meg a Java-osztályt és a kivételkezelő kazánlemezt. A kód olyan függvények összeláncolására szolgál Optional.flatMap
, amelyek üres Optional
értéket adhatnak vissza. A kód rövidítése flatMap
és egyértelművé teszi a kódot, de vegye figyelembe, hogy getRequestBody()
a kivételek nem nyelik el a kódot.
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Optional;
// JSON library
import com.google.gson.Gson;
String scoringUri = "scoring-endpoint";
String tenantId = "your-tenant-id";
String clientId = "your-client-id";
String clientSecret = "your-client-secret";
String resourceManagerUrl = "https://management.azure.com";
String dataToBeScored = "{ \"ExperimentName\" : \"My_Pipeline\", \"ParameterAssignments\" : { \"pipeline_arg\" : \"20\" }}";
HttpClient client = HttpClient.newBuilder().build();
Gson gson = new Gson();
HttpRequest tokenAuthenticationRequest = tokenAuthenticationRequest(tenantId, clientId, clientSecret, resourceManagerUrl);
Optional<String> authBody = getRequestBody(client, tokenAuthenticationRequest);
Optional<String> authKey = authBody.flatMap(body -> Optional.of(gson.fromJson(body, AuthenticationBody.class).access_token);;
Optional<HttpRequest> scoringRequest = authKey.flatMap(key -> Optional.of(scoringRequest(key, scoringUri, dataToBeScored)));
Optional<String> scoringResult = scoringRequest.flatMap(req -> getRequestBody(client, req));
// ... etc (`scoringResult.orElse()`) ...
static HttpRequest tokenAuthenticationRequest(String tenantId, String clientId, String clientSecret, String resourceManagerUrl)
{
String authUrl = String.format("https://login.microsoftonline.com/%s/oauth2/token", tenantId);
String clientIdParam = String.format("client_id=%s", clientId);
String resourceParam = String.format("resource=%s", resourceManagerUrl);
String clientSecretParam = String.format("client_secret=%s", clientSecret);
String bodyString = String.format("grant_type=client_credentials&%s&%s&%s", clientIdParam, resourceParam, clientSecretParam);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(authUrl))
.POST(HttpRequest.BodyPublishers.ofString(bodyString))
.build();
return request;
}
static HttpRequest scoringRequest(String authKey, String scoringUri, String dataToBeScored)
{
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(scoringUri))
.header("Authorization", String.format("Token %s", authKey))
.POST(HttpRequest.BodyPublishers.ofString(dataToBeScored))
.build();
return request;
}
static Optional<String> getRequestBody(HttpClient client, HttpRequest request) {
try {
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() != 200) {
System.out.println(String.format("Unexpected server response %d", response.statusCode()));
return Optional.empty();
}
return Optional.of(response.body());
}catch(Exception x)
{
System.out.println(x.toString());
return Optional.empty();
}
}
class AuthenticationBody {
String access_token;
String token_type;
int expires_in;
String scope;
String refresh_token;
String id_token;
AuthenticationBody() {}
}
Adathalmazok és adatátutasítások módosítása újratanítás nélkül
Érdemes lehet betanítást és következtetést végezni a különböző adathalmazokra és adatútlevelekre. Előfordulhat például, hogy kisebb adathalmazra szeretne betanítást végezni, de a teljes adatkészletre következtet. A kérelem json
argumentumában található DataSetDefinitionValueAssignments
kulccsal válthat adathalmazokra. A datapaths kapcsolója a DataPathAssignments
. Mindkét módszer hasonló:
A folyamatdefiníciós szkriptben hozzon létre egy
PipelineParameter
adathalmazt. Hozzon létre egyDatasetConsumptionConfig
vagyDataPath
aPipelineParameter
következőből:tabular_dataset = Dataset.Tabular.from_delimited_files('https://dprepdata.blob.core.windows.net/demo/Titanic.csv') tabular_pipeline_param = PipelineParameter(name="tabular_ds_param", default_value=tabular_dataset) tabular_ds_consumption = DatasetConsumptionConfig("tabular_dataset", tabular_pipeline_param)
Az ML-szkriptben a dinamikusan megadott adatkészletet a következővel
Run.get_context().input_datasets
érheti el:from azureml.core import Run input_tabular_ds = Run.get_context().input_datasets['tabular_dataset'] dataframe = input_tabular_ds.to_pandas_dataframe() # ... etc ...
Figyelje meg, hogy az ML-szkript a () számára
DatasetConsumptionConfig
megadott értéket éri el, nem pedig aPipelineParameter
(tabular_ds_param
)tabular_dataset
értékét.A folyamatdefiníciós szkriptben állítsa a
DatasetConsumptionConfig
paramétert aPipelineScriptStep
következőre:train_step = PythonScriptStep( name="train_step", script_name="train_with_dataset.py", arguments=["--param1", tabular_ds_consumption], inputs=[tabular_ds_consumption], compute_target=compute_target, source_directory=source_directory) pipeline = Pipeline(workspace=ws, steps=[train_step])
Ha dinamikusan szeretne adathalmazokat váltani a következtetési REST-hívásban, használja a következőt
DataSetDefinitionValueAssignments
:tabular_ds1 = Dataset.Tabular.from_delimited_files('path_to_training_dataset') tabular_ds2 = Dataset.Tabular.from_delimited_files('path_to_inference_dataset') ds1_id = tabular_ds1.id d22_id = tabular_ds2.id response = requests.post(rest_endpoint, headers=aad_token, json={ "ExperimentName": "MyRestPipeline", "DataSetDefinitionValueAssignments": { "tabular_ds_param": { "SavedDataSetReference": {"Id": ds1_id #or ds2_id }}}})
A Showcasing Dataset and PipelineParameter és Showcasing DataPath and PipelineParameter jegyzetfüzetek teljes példákat mutatnak erre a technikára.
Verziószámozott folyamatvégpont létrehozása
Létrehozhat egy folyamatvégpontot, amely mögött több közzétett folyamat is van. Ez a technika rögzített REST-végpontot biztosít az ml-folyamatok iterációja és frissítése során.
from azureml.pipeline.core import PipelineEndpoint
published_pipeline = PublishedPipeline.get(workspace=ws, id="My_Published_Pipeline_id")
pipeline_endpoint = PipelineEndpoint.publish(workspace=ws, name="PipelineEndpointTest",
pipeline=published_pipeline, description="Test description Notebook")
Feladat elküldése folyamatvégpontra
Feladat elküldhető a folyamatvégpont alapértelmezett verziójára:
pipeline_endpoint_by_name = PipelineEndpoint.get(workspace=ws, name="PipelineEndpointTest")
run_id = pipeline_endpoint_by_name.submit("PipelineEndpointExperiment")
print(run_id)
A feladatokat egy adott verzióra is elküldheti:
run_id = pipeline_endpoint_by_name.submit("PipelineEndpointExperiment", pipeline_version="0")
print(run_id)
Ugyanez a REST API-val is elvégezhető:
rest_endpoint = pipeline_endpoint_by_name.endpoint
response = requests.post(rest_endpoint,
headers=aad_token,
json={"ExperimentName": "PipelineEndpointExperiment",
"RunSource": "API",
"ParameterAssignments": {"1": "united", "2":"city"}})
Közzétett folyamatok használata a studióban
A közzétett folyamatot a stúdióból is futtathatja:
Jelentkezzen be az Azure Machine Tanulás Studióba.
A munkaterület megtekintése.
A bal oldalon válassza a Végpontok lehetőséget.
Felül válassza ki a Folyamatvégpontok lehetőséget.
Válasszon ki egy adott folyamatot a folyamatvégpont korábbi futtatási eredményeinek futtatásához, felhasználásához vagy áttekintéséhez.
Közzétett folyamat letiltása
Ha el szeretne rejteni egy folyamatot a közzétett folyamatok listájából, tiltsa le a studióban vagy az SDK-ban:
# Get the pipeline by using its ID from Azure Machine Learning studio
p = PublishedPipeline.get(ws, id="068f4885-7088-424b-8ce2-eeb9ba5381a6")
p.disable()
Újra engedélyezhető a . használatával p.enable()
. További információ: PublishedPipeline osztályhivatkozás .
Következő lépések
- Ezeket a Jupyter-jegyzetfüzeteket a GitHubon használhatja a gépi tanulási folyamatok további megismeréséhez.
- Tekintse meg az azureml-pipelines-core csomag és az azureml-pipelines-steps csomag SDK-referencia súgóját.
- A folyamatok hibakeresésével és hibaelhárításával kapcsolatos tippekért tekintse meg a útmutatót.