Rövid útmutató: Objektumészlelési projekt létrehozása a Custom Vision ügyfélkódtárával
A .NET-hez készült Custom Vision ügyfélkódtár használatának első lépései. Az alábbi lépések végrehajtásával telepítheti a csomagot, és kipróbálhatja az objektumészlelési modell létrehozásához használt példakódot. Létrehoz egy projektet, címkéket ad hozzá, mintaképeken tanítja be a projektet, és a projekt előrejelzési végpontJÁNAK URL-címével programozott módon teszteli azt. Ezt a példát használhatja sablonként saját képfelismerő alkalmazás létrehozásához.
Feljegyzés
Ha kód írása nélkül szeretne objektumészlelési modellt készíteni és betaníteni, tekintse meg inkább a böngészőalapú útmutatást.
Referenciadokumentáció | Kódtár forráskódja (betanítás)(előrejelzés) | Csomag (NuGet) (betanítás)(előrejelzés) | Minták
Előfeltételek
- Azure-előfizetés – Ingyenes létrehozás
- A Visual Studio IDE vagy a .NET Core aktuális verziója.
- Miután megkapta az Azure-előfizetését, hozzon létre egy Custom Vision-erőforrást az Azure Portalon egy betanítási és előrejelzési erőforrás létrehozásához.
- Az ingyenes tarifacsomag (
F0
) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben.
- Az ingyenes tarifacsomag (
Környezeti változók létrehozása
Ebben a példában a hitelesítő adatokat az alkalmazást futtató helyi gépen lévő környezeti változókba fogja írni.
Nyissa meg az Azure Portalt. Ha az Előfeltételek szakaszban létrehozott Custom Vision-erőforrások sikeresen üzembe helyezve, válassza az Erőforrás megnyitása gombot a Következő lépések csoportban. A kulcsokat és végpontokat az erőforrások kulcs- és végpontoldalain, az erőforrás-kezelés alatt találja. Be kell szereznie a betanítási és előrejelzési erőforrások kulcsait, valamint az API-végpontokat.
Az előrejelzési erőforrás-azonosítót az előrejelzési erőforrás Tulajdonságok lapján találja az Azure Portalon, erőforrás-azonosítóként felsorolva.
Tipp.
Ezeket az értékeket is lekérheti https://www.customvision.ai/ . Bejelentkezés után kattintson a jobb felső sarokban található Gépház ikonra. A Beállítás lapon megtekintheti az összes kulcsot, erőforrás-azonosítót és végpontot.
Figyelem
Ne vegye fel közvetlenül a kulcsot a kódba, és soha ne tegye közzé nyilvánosan. Az Azure AI-szolgáltatások biztonsági cikkében további hitelesítési lehetőségeket talál, például az Azure Key Vaultot.
A környezeti változók beállításához nyisson meg egy konzolablakot, és kövesse az operációs rendszer és a fejlesztési környezet utasításait.
- A
VISION_TRAINING KEY
környezeti változó beállításához cserélje leyour-training-key
a betanítási erőforrás egyik kulcsára. - A
VISION_TRAINING_ENDPOINT
környezeti változó beállításához cserélje leyour-training-endpoint
a betanítási erőforrás végpontját. - A
VISION_PREDICTION_KEY
környezeti változó beállításához cserélje leyour-prediction-key
az előrejelzési erőforrás egyik kulcsára. - A
VISION_PREDICTION_ENDPOINT
környezeti változó beállításához cserélje leyour-prediction-endpoint
az előrejelzési erőforrás végpontját. - A
VISION_PREDICTION_RESOURCE_ID
környezeti változó beállításához cserélje leyour-resource-id
az előrejelzési erőforrás erőforrás-azonosítóját.
setx VISION_TRAINING_KEY your-training-key
setx VISION_TRAINING_ENDPOINT your-training-endpoint
setx VISION_PREDICTION_KEY your-prediction-key
setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint
setx VISION_PREDICTION_RESOURCE_ID your-resource-id
A környezeti változók hozzáadása után előfordulhat, hogy újra kell indítania a futó programokat, amelyek felolvassák a környezeti változókat, beleértve a konzolablakot is.
Beállítás
Új C#-alkalmazás létrehozása
A Visual Studio használatával hozzon létre egy új .NET Core-alkalmazást.
Telepítse az ügyfélkódtárat
Miután létrehozott egy új projektet, telepítse az ügyfélkódtárat a jobb gombbal a projektmegoldásra kattintva a Megoldáskezelő, és válassza a NuGet-csomagok kezelése lehetőséget. A megnyíló csomagkezelőben válassza a Tallózás lehetőséget, jelölje be az Előrendelés belefoglalása jelölőnégyzetet, és keressen Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training
rá és Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction
. Válassza ki a legújabb verziót, majd telepítse.
Tipp.
Szeretné egyben megtekinteni a teljes gyorsútmutatós kódfájlt? Megtalálhatja a GitHubon, amely a gyorsútmutató kódmintáit is tartalmazza.
Nyissa meg a program.cs fájlt a projektkönyvtárban, és adja hozzá a következő using
irányelveket:
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
Az alkalmazás fő metódusában hozzon létre olyan változókat, amelyek lekérik az erőforrás kulcsait és végpontját a környezeti változókból. Emellett deklarál néhány alapvető objektumot is, amelyeket később használni fog.
string trainingEndpoint = Environment.GetEnvironmentVariable("VISION_TRAINING_ENDPOINT");
string trainingKey = Environment.GetEnvironmentVariable("VISION_TRAINING_KEY");
string predictionEndpoint = Environment.GetEnvironmentVariable("VISION_PREDICTION_ENDPOINT");
string predictionKey = Environment.GetEnvironmentVariable("VISION_PREDICTION_KEY");
private static Iteration iteration;
private static string publishedModelName = "CustomODModel";
Az alkalmazás Fő metódusában adja hozzá az ebben a rövid útmutatóban használt metódusok hívásait. Ezeket később fogja implementálni.
CustomVisionTrainingClient trainingApi = AuthenticateTraining(trainingEndpoint, trainingKey);
CustomVisionPredictionClient predictionApi = AuthenticatePrediction(predictionEndpoint, predictionKey);
Project project = CreateProject(trainingApi);
AddTags(trainingApi, project);
UploadImages(trainingApi, project);
TrainProject(trainingApi, project);
PublishIteration(trainingApi, project);
TestIteration(predictionApi, project);
Az ügyfél hitelesítése
Egy új módszerrel példányosíthatja a betanítási és előrejelzési ügyfeleket a végpont és a kulcsok használatával.
private CustomVisionTrainingClient AuthenticateTraining(string endpoint, string trainingKey, string predictionKey)
{
// Create the Api, passing in the training key
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials(trainingKey))
{
Endpoint = endpoint
};
return trainingApi;
}
private CustomVisionPredictionClient AuthenticatePrediction(string endpoint, string predictionKey)
{
// Create a prediction endpoint, passing in the obtained prediction key
CustomVisionPredictionClient predictionApi = new CustomVisionPredictionClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.ApiKeyServiceClientCredentials(predictionKey))
{
Endpoint = endpoint
};
return predictionApi;
}
Új Custom Vision-projekt létrehozása
Ez a következő metódus létrehoz egy objektumészlelési projektet. A létrehozott projekt megjelenik a Custom Vision webhelyén. A projekt létrehozásakor a CreateProject metódussal további lehetőségeket is megadhat (erről a Detektor létrehozása webes portál útmutatójában olvashat).
private Project CreateProject(CustomVisionTrainingClient trainingApi)
{
// Find the object detection domain
var domains = trainingApi.GetDomains();
var objDetectionDomain = domains.FirstOrDefault(d => d.Type == "ObjectDetection");
// Create a new project
Console.WriteLine("Creating new project:");
project = trainingApi.CreateProject("My New Project", null, objDetectionDomain.Id);
return project;
}
Címkék hozzáadása a projekthez
Ez a módszer határozza meg a modell betanítása során használni kívánt címkéket.
private void AddTags(CustomVisionTrainingClient trainingApi, Project project)
{
// Make two tags in the new project
var forkTag = trainingApi.CreateTag(project.Id, "fork");
var scissorsTag = trainingApi.CreateTag(project.Id, "scissors");
}
Képek feltöltése és címkézése
Először töltse le a projekt mintaképét. Mentse a Mintaképek mappa tartalmát a helyi eszközre.
Ha képeket címkéz meg az objektumészlelési projektekben, meg kell adnia a címkével ellátott objektumok régióját a normalizált koordináták használatával. Az alábbi kód a címkével ellátott régiójához társítja mindegyik mintaképet.
private void UploadImages(CustomVisionTrainingClient trainingApi, Project project)
{
Dictionary<string, double[]> fileToRegionMap = new Dictionary<string, double[]>()
{
// FileName, Left, Top, Width, Height
{"scissors_1", new double[] { 0.4007353, 0.194068655, 0.259803921, 0.6617647 } },
{"scissors_2", new double[] { 0.426470578, 0.185898721, 0.172794119, 0.5539216 } },
{"scissors_3", new double[] { 0.289215684, 0.259428144, 0.403186262, 0.421568632 } },
{"scissors_4", new double[] { 0.343137264, 0.105833367, 0.332107842, 0.8055556 } },
{"scissors_5", new double[] { 0.3125, 0.09766343, 0.435049027, 0.71405226 } },
{"scissors_6", new double[] { 0.379901975, 0.24308826, 0.32107842, 0.5718954 } },
{"scissors_7", new double[] { 0.341911763, 0.20714055, 0.3137255, 0.6356209 } },
{"scissors_8", new double[] { 0.231617644, 0.08459154, 0.504901946, 0.8480392 } },
{"scissors_9", new double[] { 0.170343131, 0.332957536, 0.767156839, 0.403594762 } },
{"scissors_10", new double[] { 0.204656869, 0.120539248, 0.5245098, 0.743464053 } },
{"scissors_11", new double[] { 0.05514706, 0.159754932, 0.799019635, 0.730392158 } },
{"scissors_12", new double[] { 0.265931368, 0.169558853, 0.5061275, 0.606209159 } },
{"scissors_13", new double[] { 0.241421565, 0.184264734, 0.448529422, 0.6830065 } },
{"scissors_14", new double[] { 0.05759804, 0.05027781, 0.75, 0.882352948 } },
{"scissors_15", new double[] { 0.191176474, 0.169558853, 0.6936275, 0.6748366 } },
{"scissors_16", new double[] { 0.1004902, 0.279036, 0.6911765, 0.477124184 } },
{"scissors_17", new double[] { 0.2720588, 0.131977156, 0.4987745, 0.6911765 } },
{"scissors_18", new double[] { 0.180147052, 0.112369314, 0.6262255, 0.6666667 } },
{"scissors_19", new double[] { 0.333333343, 0.0274019931, 0.443627447, 0.852941155 } },
{"scissors_20", new double[] { 0.158088237, 0.04047389, 0.6691176, 0.843137264 } },
{"fork_1", new double[] { 0.145833328, 0.3509314, 0.5894608, 0.238562092 } },
{"fork_2", new double[] { 0.294117659, 0.216944471, 0.534313738, 0.5980392 } },
{"fork_3", new double[] { 0.09191177, 0.0682516545, 0.757352948, 0.6143791 } },
{"fork_4", new double[] { 0.254901975, 0.185898721, 0.5232843, 0.594771266 } },
{"fork_5", new double[] { 0.2365196, 0.128709182, 0.5845588, 0.71405226 } },
{"fork_6", new double[] { 0.115196079, 0.133611143, 0.676470637, 0.6993464 } },
{"fork_7", new double[] { 0.164215669, 0.31008172, 0.767156839, 0.410130739 } },
{"fork_8", new double[] { 0.118872553, 0.318251669, 0.817401946, 0.225490168 } },
{"fork_9", new double[] { 0.18259804, 0.2136765, 0.6335784, 0.643790841 } },
{"fork_10", new double[] { 0.05269608, 0.282303959, 0.8088235, 0.452614367 } },
{"fork_11", new double[] { 0.05759804, 0.0894935, 0.9007353, 0.3251634 } },
{"fork_12", new double[] { 0.3345588, 0.07315363, 0.375, 0.9150327 } },
{"fork_13", new double[] { 0.269607842, 0.194068655, 0.4093137, 0.6732026 } },
{"fork_14", new double[] { 0.143382356, 0.218578458, 0.7977941, 0.295751631 } },
{"fork_15", new double[] { 0.19240196, 0.0633497, 0.5710784, 0.8398692 } },
{"fork_16", new double[] { 0.140931368, 0.480016381, 0.6838235, 0.240196079 } },
{"fork_17", new double[] { 0.305147052, 0.2512582, 0.4791667, 0.5408496 } },
{"fork_18", new double[] { 0.234068632, 0.445702642, 0.6127451, 0.344771236 } },
{"fork_19", new double[] { 0.219362751, 0.141781077, 0.5919118, 0.6683006 } },
{"fork_20", new double[] { 0.180147052, 0.239820287, 0.6887255, 0.235294119 } }
};
Feljegyzés
Ha nem rendelkezik kattintással és húzással a régiók koordinátáinak megjelölésére szolgáló segédprogrammal, a Custom Vision webhelyén használhatja a webes felhasználói felületet. Ebben a példában a koordináták már meg vannak adva.
Az egyes mintaképek és régiókoordinátáik ezután ezzel a társítási térképpel tölthetők fel. Egyetlen kötegben legfeljebb 64 képet tölthet fel. Előfordulhat, hogy módosítania kell az imagePath
értéket, hogy a megfelelő mappahelyekre mutasson.
// Add all images for fork
var imagePath = Path.Combine("Images", "fork");
var imageFileEntries = new List<ImageFileCreateEntry>();
foreach (var fileName in Directory.EnumerateFiles(imagePath))
{
var region = fileToRegionMap[Path.GetFileNameWithoutExtension(fileName)];
imageFileEntries.Add(new ImageFileCreateEntry(fileName, File.ReadAllBytes(fileName), null, new List<Region>(new Region[] { new Region(forkTag.Id, region[0], region[1], region[2], region[3]) })));
}
trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFileEntries));
// Add all images for scissors
imagePath = Path.Combine("Images", "scissors");
imageFileEntries = new List<ImageFileCreateEntry>();
foreach (var fileName in Directory.EnumerateFiles(imagePath))
{
var region = fileToRegionMap[Path.GetFileNameWithoutExtension(fileName)];
imageFileEntries.Add(new ImageFileCreateEntry(fileName, File.ReadAllBytes(fileName), null, new List<Region>(new Region[] { new Region(scissorsTag.Id, region[0], region[1], region[2], region[3]) })));
}
trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFileEntries));
}
Ezen a ponton feltöltötte az összes mintaképet, és mindegyik (elágazás vagy olló) címkézett egy hozzá tartozó képpont téglalapot.
A projekt tanítása
Ez a módszer hozza létre az első betanítási iterációt a projektben. A betanítás befejezéséig lekérdezi a szolgáltatást.
private void TrainProject(CustomVisionTrainingClient trainingApi, Project project)
{
// Now there are images with tags start training the project
Console.WriteLine("\tTraining");
iteration = trainingApi.TrainProject(project.Id);
// The returned iteration will be in progress, and can be queried periodically to see when it has completed
while (iteration.Status == "Training")
{
Thread.Sleep(1000);
// Re-query the iteration to get its updated status
iteration = trainingApi.GetIteration(project.Id, iteration.Id);
}
}
Tipp.
Betanítása kijelölt címkékkel
Igény szerint csak az alkalmazott címkék egy részhalmazára taníthat be. Ezt akkor érdemes megtennie, ha még nem alkalmazott elég címkét bizonyos címkék közül, de van elég más. A TrainProject hívásban használja a trainingParameters paramétert. Hozzon létre egy TrainingParameters tulajdonságot, és állítsa be a SelectedTags tulajdonságát a használni kívánt címkék azonosítóinak listájára. A modell betanítása csak a lista címkéinek felismerésére fog betanulni.
Az aktuális iteráció közzététele
Ezzel a módszerrel a modell aktuális iterációja elérhető lesz a lekérdezéshez. A modell neve hivatkozásként használható előrejelzési kérések küldéséhez. Meg kell adnia a saját értékét a következőhöz predictionResourceId
: . Az előrejelzési erőforrás-azonosítót az Azure Portal Tulajdonságok lapján találja, erőforrás-azonosítóként felsorolva.
private void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{
// The iteration is now trained. Publish it to the prediction end point.
var predictionResourceId = Environment.GetEnvironmentVariable("VISION_PREDICTION_RESOURCE_ID");
trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
Console.WriteLine("Done!\n");
}
Az előrejelzési végpont tesztelése
Ez a metódus betölti a tesztrendszerképet, lekérdezi a modell végpontját, és előrejelzési adatokat ad ki a konzolon.
private void TestIteration(CustomVisionPredictionClient predictionApi, Project project)
{
// Make a prediction against the new project
Console.WriteLine("Making a prediction:");
var imageFile = Path.Combine("Images", "test", "test_image.jpg");
using (var stream = File.OpenRead(imageFile))
{
var result = predictionApi.DetectImage(project.Id, publishedModelName, stream);
// Loop over each prediction and write out the results
foreach (var c in result.Predictions)
{
Console.WriteLine($"\t{c.TagName}: {c.Probability:P1} [ {c.BoundingBox.Left}, {c.BoundingBox.Top}, {c.BoundingBox.Width}, {c.BoundingBox.Height} ]");
}
}
Console.ReadKey();
}
Az alkalmazás futtatása
Futtassa az alkalmazást az IDE ablak tetején található Hibakeresés gombra kattintva.
A futtatása során az alkalmazásnak meg kell nyitnia egy konzolablakot, és az alábbi kimenetet kell megjelenítenie:
Creating new project:
Training
Done!
Making a prediction:
fork: 98.2% [ 0.111609578, 0.184719115, 0.6607002, 0.6637112 ]
scissors: 1.2% [ 0.112389535, 0.119195729, 0.658031344, 0.7023591 ]
Ezután ellenőrizheti, hogy a tesztkép (az Images/Test/ mappában található) megfelelően lett-e megcímkézve, és helyes-e az észlelési régió. Az alkalmazásból való kilépéshez nyomja le bármelyik billentyűt.
Az erőforrások eltávolítása
Ha saját objektumészlelési projektet szeretne megvalósítani (vagy ehelyett egy képosztályozási projektet szeretne kipróbálni), érdemes törölnie a példából a villa-/ollóészlelési projektet. Az ingyenes előfizetés két Custom Vision-projektet tesz lehetővé.
A Custom Vision webhelyén lépjen a projektekhez, és kattintson a My New Project panel alsó részén található kuka ikonra.
Következő lépések
Most elvégezte az objektumészlelési folyamat minden lépését a kódban. Ez a minta egyetlen betanítási iterációt hajt végre, de gyakran többször kell betanítania és tesztelnie a modellt, hogy pontosabb legyen. Az alábbi útmutató a képosztályozással foglalkozik, az alapelvei azonban hasonlóak az objektumészlelés alapelveihez.
- Mi az a Custom Vision?
- A minta forráskódja a GitHubon található
- SDK-referenciadokumentáció
Ez az útmutató útmutatást és mintakódot tartalmaz, amelyek segítenek a Custom Vision Go ügyfélkódtárának használatának megkezdésében egy objektumészlelési modell létrehozásához. Létrehoz egy projektet, címkéket ad hozzá, betanítja a projektet, és a projekt előrejelzési végpontJÁNAK URL-címével programozott módon teszteli azt. Ezt a példát használhatja sablonként saját képfelismerő alkalmazás létrehozásához.
Feljegyzés
Ha kód írása nélkül szeretne objektumészlelési modellt készíteni és betaníteni, tekintse meg inkább a böngészőalapú útmutatást.
Használja a Custom Vision ügyféloldali kódtárát a Következőhöz:
- Új Custom Vision-projekt létrehozása
- Címkék hozzáadása a projekthez
- Képek feltöltése és címkézése
- A projekt tanítása
- Az aktuális iteráció közzététele
- Az előrejelzési végpont tesztelése
Referenciadokumentáció (képzés)(előrejelzés)
Előfeltételek
- Azure-előfizetés – Ingyenes létrehozás
- Ugrás 1,8+
- Miután megkapta az Azure-előfizetését, hozzon létre egy Custom Vision-erőforrást az Azure Portalon egy betanítási és előrejelzési erőforrás létrehozásához.
- Az ingyenes tarifacsomag (
F0
) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben.
- Az ingyenes tarifacsomag (
Környezeti változók létrehozása
Ebben a példában a hitelesítő adatokat az alkalmazást futtató helyi gépen lévő környezeti változókba fogja írni.
Nyissa meg az Azure Portalt. Ha az Előfeltételek szakaszban létrehozott Custom Vision-erőforrások sikeresen üzembe helyezve, válassza az Erőforrás megnyitása gombot a Következő lépések csoportban. A kulcsokat és végpontokat az erőforrások kulcs- és végpontoldalain, az erőforrás-kezelés alatt találja. Be kell szereznie a betanítási és előrejelzési erőforrások kulcsait, valamint az API-végpontokat.
Az előrejelzési erőforrás-azonosítót az előrejelzési erőforrás Tulajdonságok lapján találja az Azure Portalon, erőforrás-azonosítóként felsorolva.
Tipp.
Ezeket az értékeket is lekérheti https://www.customvision.ai/ . Bejelentkezés után kattintson a jobb felső sarokban található Gépház ikonra. A Beállítás lapon megtekintheti az összes kulcsot, erőforrás-azonosítót és végpontot.
Figyelem
Ne vegye fel közvetlenül a kulcsot a kódba, és soha ne tegye közzé nyilvánosan. Az Azure AI-szolgáltatások biztonsági cikkében további hitelesítési lehetőségeket talál, például az Azure Key Vaultot.
A környezeti változók beállításához nyisson meg egy konzolablakot, és kövesse az operációs rendszer és a fejlesztési környezet utasításait.
- A
VISION_TRAINING KEY
környezeti változó beállításához cserélje leyour-training-key
a betanítási erőforrás egyik kulcsára. - A
VISION_TRAINING_ENDPOINT
környezeti változó beállításához cserélje leyour-training-endpoint
a betanítási erőforrás végpontját. - A
VISION_PREDICTION_KEY
környezeti változó beállításához cserélje leyour-prediction-key
az előrejelzési erőforrás egyik kulcsára. - A
VISION_PREDICTION_ENDPOINT
környezeti változó beállításához cserélje leyour-prediction-endpoint
az előrejelzési erőforrás végpontját. - A
VISION_PREDICTION_RESOURCE_ID
környezeti változó beállításához cserélje leyour-resource-id
az előrejelzési erőforrás erőforrás-azonosítóját.
setx VISION_TRAINING_KEY your-training-key
setx VISION_TRAINING_ENDPOINT your-training-endpoint
setx VISION_PREDICTION_KEY your-prediction-key
setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint
setx VISION_PREDICTION_RESOURCE_ID your-resource-id
A környezeti változók hozzáadása után előfordulhat, hogy újra kell indítania a futó programokat, amelyek felolvassák a környezeti változókat, beleértve a konzolablakot is.
Beállítás
A Custom Vision ügyfélkódtár telepítése
Ha a Custom Vision for Go-val szeretne képelemzési alkalmazást írni, szüksége lesz a Custom Vision szolgáltatás ügyfélkódtárára. Futtassa az alábbi parancsot a PowerShellben:
go get -u github.com/Azure/azure-sdk-for-go/...
vagy ha használja dep
, futtassa az adattáron belül a következőt:
dep ensure -add github.com/Azure/azure-sdk-for-go
Mintaképek letöltése
Ez a példa az Azure AI-szolgáltatások Python SDK-mintatárából származó képeket használja a GitHubon. Klónozza vagy töltse le ezt az adattárat a fejlesztői környezetbe. Jegyezze meg a mappa helyét egy későbbi lépésben.
A Custom Vision-projekt létrehozása
Hozzon létre egy sample.go nevű új fájlt az előnyben részesített projektkönyvtárban, és nyissa meg az előnyben részesített kódszerkesztőben.
Adja hozzá a következő kódot a szkripthez egy új Custom Vision Service-projekt létrehozásához.
A projekt létrehozásakor a CreateProject metódussal további lehetőségeket is megadhat (erről a Detektor létrehozása webes portál útmutatójában olvashat).
import(
"context"
"bytes"
"fmt"
"io/ioutil"
"path"
"log"
"time"
"github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/training"
"github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/prediction"
)
// retrieve environment variables:
var (
training_key string = os.Getenv("VISION_TRAINING_KEY")
prediction_key string = os.Getenv("VISION_PREDICTION_KEY")
prediction_resource_id = os.Getenv("VISION_PREDICTION_RESOURCE_ID")
endpoint string = os.Getenv("VISION_ENDPOINT")
project_name string = "Go Sample OD Project"
iteration_publish_name = "detectModel"
sampleDataDirectory = "<path to sample images>"
)
func main() {
fmt.Println("Creating project...")
ctx = context.Background()
trainer := training.New(training_key, endpoint)
var objectDetectDomain training.Domain
domains, _ := trainer.GetDomains(ctx)
for _, domain := range *domains.Value {
fmt.Println(domain, domain.Type)
if domain.Type == "ObjectDetection" && *domain.Name == "General" {
objectDetectDomain = domain
break
}
}
fmt.Println("Creating project...")
project, _ := trainer.CreateProject(ctx, project_name, "", objectDetectDomain.ID, "")
Címkék létrehozása a projektben
Ha besorolási címkéket szeretne létrehozni a projekthez, adja hozzá a következő kódot a sample.go végéhez:
# Make two tags in the new project
forkTag, _ := trainer.CreateTag(ctx, *project.ID, "fork", "A fork", string(training.Regular))
scissorsTag, _ := trainer.CreateTag(ctx, *project.ID, "scissors", "Pair of scissors", string(training.Regular))
Képek feltöltése és címkézése
Ha képeket címkéz meg az objektumészlelési projektekben, meg kell adnia a címkével ellátott objektumok régióját a normalizált koordináták használatával.
Feljegyzés
Ha nem rendelkezik kattintással és húzással a régiók koordinátáinak megjelöléséhez, használhatja a webes felhasználói felületet a Customvision.ai. Ebben a példában a koordináták már meg vannak adva.
A képek, címkék és régiók projekthez való hozzáadásához szúrja be az alábbi kódot a címke létrehozása után. Vegye figyelembe, hogy ebben az oktatóanyagban a régiók kódolt beágyazottak. A régiók normalizált koordinátákban adják meg a határolókeretet, és a következő sorrendben adják meg a koordinátákat: bal oldali, felső, szélesség, magasság.
forkImageRegions := map[string][4]float64{
"fork_1.jpg": [4]float64{ 0.145833328, 0.3509314, 0.5894608, 0.238562092 },
"fork_2.jpg": [4]float64{ 0.294117659, 0.216944471, 0.534313738, 0.5980392 },
"fork_3.jpg": [4]float64{ 0.09191177, 0.0682516545, 0.757352948, 0.6143791 },
"fork_4.jpg": [4]float64{ 0.254901975, 0.185898721, 0.5232843, 0.594771266 },
"fork_5.jpg": [4]float64{ 0.2365196, 0.128709182, 0.5845588, 0.71405226 },
"fork_6.jpg": [4]float64{ 0.115196079, 0.133611143, 0.676470637, 0.6993464 },
"fork_7.jpg": [4]float64{ 0.164215669, 0.31008172, 0.767156839, 0.410130739 },
"fork_8.jpg": [4]float64{ 0.118872553, 0.318251669, 0.817401946, 0.225490168 },
"fork_9.jpg": [4]float64{ 0.18259804, 0.2136765, 0.6335784, 0.643790841 },
"fork_10.jpg": [4]float64{ 0.05269608, 0.282303959, 0.8088235, 0.452614367 },
"fork_11.jpg": [4]float64{ 0.05759804, 0.0894935, 0.9007353, 0.3251634 },
"fork_12.jpg": [4]float64{ 0.3345588, 0.07315363, 0.375, 0.9150327 },
"fork_13.jpg": [4]float64{ 0.269607842, 0.194068655, 0.4093137, 0.6732026 },
"fork_14.jpg": [4]float64{ 0.143382356, 0.218578458, 0.7977941, 0.295751631 },
"fork_15.jpg": [4]float64{ 0.19240196, 0.0633497, 0.5710784, 0.8398692 },
"fork_16.jpg": [4]float64{ 0.140931368, 0.480016381, 0.6838235, 0.240196079 },
"fork_17.jpg": [4]float64{ 0.305147052, 0.2512582, 0.4791667, 0.5408496 },
"fork_18.jpg": [4]float64{ 0.234068632, 0.445702642, 0.6127451, 0.344771236 },
"fork_19.jpg": [4]float64{ 0.219362751, 0.141781077, 0.5919118, 0.6683006 },
"fork_20.jpg": [4]float64{ 0.180147052, 0.239820287, 0.6887255, 0.235294119 },
}
scissorsImageRegions := map[string][4]float64{
"scissors_1.jpg": [4]float64{ 0.4007353, 0.194068655, 0.259803921, 0.6617647 },
"scissors_2.jpg": [4]float64{ 0.426470578, 0.185898721, 0.172794119, 0.5539216 },
"scissors_3.jpg": [4]float64{ 0.289215684, 0.259428144, 0.403186262, 0.421568632 },
"scissors_4.jpg": [4]float64{ 0.343137264, 0.105833367, 0.332107842, 0.8055556 },
"scissors_5.jpg": [4]float64{ 0.3125, 0.09766343, 0.435049027, 0.71405226 },
"scissors_6.jpg": [4]float64{ 0.379901975, 0.24308826, 0.32107842, 0.5718954 },
"scissors_7.jpg": [4]float64{ 0.341911763, 0.20714055, 0.3137255, 0.6356209 },
"scissors_8.jpg": [4]float64{ 0.231617644, 0.08459154, 0.504901946, 0.8480392 },
"scissors_9.jpg": [4]float64{ 0.170343131, 0.332957536, 0.767156839, 0.403594762 },
"scissors_10.jpg": [4]float64{ 0.204656869, 0.120539248, 0.5245098, 0.743464053 },
"scissors_11.jpg": [4]float64{ 0.05514706, 0.159754932, 0.799019635, 0.730392158 },
"scissors_12.jpg": [4]float64{ 0.265931368, 0.169558853, 0.5061275, 0.606209159 },
"scissors_13.jpg": [4]float64{ 0.241421565, 0.184264734, 0.448529422, 0.6830065 },
"scissors_14.jpg": [4]float64{ 0.05759804, 0.05027781, 0.75, 0.882352948 },
"scissors_15.jpg": [4]float64{ 0.191176474, 0.169558853, 0.6936275, 0.6748366 },
"scissors_16.jpg": [4]float64{ 0.1004902, 0.279036, 0.6911765, 0.477124184 },
"scissors_17.jpg": [4]float64{ 0.2720588, 0.131977156, 0.4987745, 0.6911765 },
"scissors_18.jpg": [4]float64{ 0.180147052, 0.112369314, 0.6262255, 0.6666667 },
"scissors_19.jpg": [4]float64{ 0.333333343, 0.0274019931, 0.443627447, 0.852941155 },
"scissors_20.jpg": [4]float64{ 0.158088237, 0.04047389, 0.6691176, 0.843137264 },
}
Ezután használja ezt a társítástérképet az egyes mintaképek régiókoordinátáival való feltöltéséhez (egyetlen kötegben legfeljebb 64 képet tölthet fel). Adja hozzá a következő kódot.
Feljegyzés
Módosítania kell a rendszerképek elérési útját annak alapján, hogy hol töltötte le korábban az Azure AI-szolgáltatások Go SDK-mintái projektet.
// Go through the data table above and create the images
fmt.Println("Adding images...")
var fork_images []training.ImageFileCreateEntry
for file, region := range forkImageRegions {
imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "fork", file))
regiontest := forkImageRegions[file]
imageRegion := training.Region{
TagID: forkTag.ID,
Left: ®iontest[0],
Top: ®iontest[1],
Width: ®iontest[2],
Height: ®iontest[3],
}
var fileName string = file
fork_images = append(fork_images, training.ImageFileCreateEntry{
Name: &fileName,
Contents: &imageFile,
Regions: &[]training.Region{imageRegion}
})
}
fork_batch, _ := trainer.CreateImagesFromFiles(ctx, *project.ID, training.ImageFileCreateBatch{
Images: &fork_images,
})
if (!*fork_batch.IsBatchSuccessful) {
fmt.Println("Batch upload failed.")
}
var scissor_images []training.ImageFileCreateEntry
for file, region := range scissorsImageRegions {
imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "scissors", file))
imageRegion := training.Region {
TagID:scissorsTag.ID,
Left:®ion[0],
Top:®ion[1],
Width:®ion[2],
Height:®ion[3],
}
scissor_images = append(scissor_images, training.ImageFileCreateEntry {
Name: &file,
Contents: &imageFile,
Regions: &[]training.Region{ imageRegion },
})
}
scissor_batch, _ := trainer.CreateImagesFromFiles(ctx, *project.ID, training.ImageFileCreateBatch{
Images: &scissor_images,
})
if (!*scissor_batch.IsBatchSuccessful) {
fmt.Println("Batch upload failed.")
}
A projekt betanítása és közzététele
Ez a kód létrehozza az előrejelzési modell első iterációját, majd közzéteszi az iterációt az előrejelzési végponton. A közzétett iterációnak megadott név használható előrejelzési kérések küldéséhez. Az iteráció csak a közzétételig érhető el az előrejelzési végponton.
iteration, _ := trainer.TrainProject(ctx, *project.ID)
fmt.Println("Training status:", *iteration.Status)
for {
if *iteration.Status != "Training" {
break
}
time.Sleep(5 * time.Second)
iteration, _ = trainer.GetIteration(ctx, *project.ID, *iteration.ID)
fmt.Println("Training status:", *iteration.Status)
}
trainer.PublishIteration(ctx, *project.ID, *iteration.ID, iteration_publish_name, prediction_resource_id))
Az előrejelzési végpont használata
A képek előrejelzési végpontra való küldéséhez és az előrejelzés lekéréséhez adja hozzá a következő kódot a fájl végéhez:
fmt.Println("Predicting...")
predictor := prediction.New(prediction_key, endpoint)
testImageData, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Test", "test_od_image.jpg"))
results, _ := predictor.DetectImage(ctx, *project.ID, iteration_publish_name, ioutil.NopCloser(bytes.NewReader(testImageData)), "")
for _, prediction := range *results.Predictions {
boundingBox := *prediction.BoundingBox
fmt.Printf("\t%s: %.2f%% (%.2f, %.2f, %.2f, %.2f)",
*prediction.TagName,
*prediction.Probability * 100,
*boundingBox.Left,
*boundingBox.Top,
*boundingBox.Width,
*boundingBox.Height)
fmt.Println("")
}
}
Az alkalmazás futtatása
Futtassa a sample.go fájlt.
go run sample.go
Az alkalmazás kimenetének meg kell jelennie a konzolon. Ezután ellenőrizheti, hogy a tesztkép (amely a samples/vision/images/Test helyen található) megfelelően lett-e megcímkézve, és helyes-e az észlelési régió.
Az erőforrások eltávolítása
Ha saját objektumészlelési projektet szeretne megvalósítani (vagy ehelyett egy képosztályozási projektet szeretne kipróbálni), érdemes törölnie a példából a villa-/ollóészlelési projektet. Az ingyenes előfizetés két Custom Vision-projektet tesz lehetővé.
A Custom Vision webhelyén lépjen a projektekhez, és kattintson a My New Project panel alsó részén található kuka ikonra.
Következő lépések
Most elvégezte az objektumészlelési folyamat minden lépését a kódban. Ez a minta egyetlen betanítási iterációt hajt végre, de gyakran többször kell betanítania és tesztelnie a modellt, hogy pontosabb legyen. Az alábbi útmutató a képosztályozással foglalkozik, az alapelvei azonban hasonlóak az objektumészlelés alapelveihez.
Ismerkedés a Java-hoz készült Custom Vision ügyfélkódtár használatával egy objektumészlelési modell létrehozásához. Az alábbi lépések végrehajtásával telepítheti a csomagot, és kipróbálhatja az alapműveletek példakódját. Ezt a példát használhatja sablonként saját képfelismerő alkalmazás létrehozásához.
Feljegyzés
Ha kód írása nélkül szeretne objektumészlelési modellt készíteni és betaníteni, tekintse meg inkább a böngészőalapú útmutatást.
A Java-hoz készült Custom Vision ügyfélkódtár használatával:
- Új Custom Vision-projekt létrehozása
- Címkék hozzáadása a projekthez
- Képek feltöltése és címkézése
- A projekt tanítása
- Az aktuális iteráció közzététele
- Az előrejelzési végpont tesztelése
Referenciadokumentáció | Kódtár forráskódja (betanítás)(előrejelzés)| Artifact (Maven) (oktatás)(előrejelzés) | Minták
Előfeltételek
- Azure-előfizetés – Ingyenes létrehozás
- A Java Development Kit (JDK) jelenlegi verziója
- A Gradle buildelési eszköz vagy egy másik függőségkezelő.
- Miután megkapta az Azure-előfizetését, hozzon létre egy Custom Vision-erőforrást az Azure Portalon egy betanítási és előrejelzési erőforrás létrehozásához.
- Az ingyenes tarifacsomag (
F0
) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben.
- Az ingyenes tarifacsomag (
Környezeti változók létrehozása
Ebben a példában a hitelesítő adatokat az alkalmazást futtató helyi gépen lévő környezeti változókba fogja írni.
Nyissa meg az Azure Portalt. Ha az Előfeltételek szakaszban létrehozott Custom Vision-erőforrások sikeresen üzembe helyezve, válassza az Erőforrás megnyitása gombot a Következő lépések csoportban. A kulcsokat és végpontokat az erőforrások kulcs- és végpontoldalain, az erőforrás-kezelés alatt találja. Be kell szereznie a betanítási és előrejelzési erőforrások kulcsait, valamint az API-végpontokat.
Az előrejelzési erőforrás-azonosítót az előrejelzési erőforrás Tulajdonságok lapján találja az Azure Portalon, erőforrás-azonosítóként felsorolva.
Tipp.
Ezeket az értékeket is lekérheti https://www.customvision.ai/ . Bejelentkezés után kattintson a jobb felső sarokban található Gépház ikonra. A Beállítás lapon megtekintheti az összes kulcsot, erőforrás-azonosítót és végpontot.
Figyelem
Ne vegye fel közvetlenül a kulcsot a kódba, és soha ne tegye közzé nyilvánosan. Az Azure AI-szolgáltatások biztonsági cikkében további hitelesítési lehetőségeket talál, például az Azure Key Vaultot.
A környezeti változók beállításához nyisson meg egy konzolablakot, és kövesse az operációs rendszer és a fejlesztési környezet utasításait.
- A
VISION_TRAINING KEY
környezeti változó beállításához cserélje leyour-training-key
a betanítási erőforrás egyik kulcsára. - A
VISION_TRAINING_ENDPOINT
környezeti változó beállításához cserélje leyour-training-endpoint
a betanítási erőforrás végpontját. - A
VISION_PREDICTION_KEY
környezeti változó beállításához cserélje leyour-prediction-key
az előrejelzési erőforrás egyik kulcsára. - A
VISION_PREDICTION_ENDPOINT
környezeti változó beállításához cserélje leyour-prediction-endpoint
az előrejelzési erőforrás végpontját. - A
VISION_PREDICTION_RESOURCE_ID
környezeti változó beállításához cserélje leyour-resource-id
az előrejelzési erőforrás erőforrás-azonosítóját.
setx VISION_TRAINING_KEY your-training-key
setx VISION_TRAINING_ENDPOINT your-training-endpoint
setx VISION_PREDICTION_KEY your-prediction-key
setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint
setx VISION_PREDICTION_RESOURCE_ID your-resource-id
A környezeti változók hozzáadása után előfordulhat, hogy újra kell indítania a futó programokat, amelyek felolvassák a környezeti változókat, beleértve a konzolablakot is.
Beállítás
Új Gradle-projekt létrehozása
Egy konzolablakban (pl. cmd, PowerShell vagy Bash) hozzon létre egy új mappát az alkalmazásnak, majd navigáljon oda.
mkdir myapp && cd myapp
Futtassa a gradle init
parancsot a munkakönyvtárból. Ez a parancs alapvető buildfájlokat hoz létre a Gradle-hez, beleértve a build.gradle.kts fájlt, amelyet futásidőben használnak az alkalmazás létrehozásához és konfigurálásához.
gradle init --type basic
Amikor a rendszer kéri, hogy válasszon egy DSL-t, válassza a Kotlin lehetőséget.
Telepítse az ügyfélkódtárat
Keresse meg a build.gradle.kts fájlt, és nyissa meg a kívánt IDE- vagy szövegszerkesztővel. Ezután másolja a következő buildkonfigurációba. Ez a konfiguráció Java-alkalmazásként definiálja a projektet, amelynek belépési pontja a CustomVisionQuickstart osztály. Importálja a Custom Vision-kódtárakat.
plugins {
java
application
}
application {
mainClassName = "CustomVisionQuickstart"
}
repositories {
mavenCentral()
}
dependencies {
compile(group = "com.azure", name = "azure-cognitiveservices-customvision-training", version = "1.1.0-preview.2")
compile(group = "com.azure", name = "azure-cognitiveservices-customvision-prediction", version = "1.1.0-preview.2")
}
Java-fájl létrehozása
A munkakönyvtárban futtassa a következő parancsot a projekt forrásmappájának létrehozásához:
mkdir -p src/main/java
Lépjen az új mappára, és hozzon létre egy CustomVisionQuickstart.java nevű fájlt. Nyissa meg a kívánt szerkesztőben vagy IDE-ben, és adja hozzá a következő import
utasításokat:
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import com.google.common.io.ByteStreams;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Classifier;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Domain;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.DomainType;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateBatch;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateEntry;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Iteration;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Project;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Region;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.TrainProjectOptionalParameter;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.Trainings;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.ImagePrediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.Prediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Tag;
Tipp.
Szeretné egyben megtekinteni a teljes gyorsútmutatós kódfájlt? Megtalálhatja a GitHubon, amely a gyorsútmutató kódmintáit is tartalmazza.
Az alkalmazás CustomVisionQuickstart osztályában olyan változókat hozhat létre, amelyek lekérik az erőforrás kulcsait és végpontját a környezeti változókból.
// retrieve environment variables
final static String trainingApiKey = System.getenv("VISION_TRAINING_KEY");
final static String trainingEndpoint = System.getenv("VISION_TRAINING_ENDPOINT");
final static String predictionApiKey = System.getenv("VISION_PREDICTION_KEY");
final static String predictionEndpoint = System.getenv("VISION_PREDICTION_ENDPOINT");
final static String predictionResourceId = System.getenv("VISION_PREDICTION_RESOURCE_ID");
Az alkalmazás fő metódusában adja hozzá az ebben a rövid útmutatóban használt metódusok hívásait. Ezeket később fogja meghatározni.
Project projectOD = createProjectOD(trainClient);
addTagsOD(trainClient, projectOD);
uploadImagesOD(trainClient, projectOD);
trainProjectOD(trainClient, projectOD);
publishIterationOD(trainClient, project);
testProjectOD(predictor, projectOD);
Objektummodell
Az alábbi osztályok és felületek a Custom Vision Java ügyfélkódtár néhány fő funkcióját kezelik.
Név | Leírás |
---|---|
CustomVisionTrainingClient | Ez az osztály kezeli a modellek létrehozását, betanítását és közzétételét. |
CustomVisionPredictionClient | Ez az osztály kezeli a modellek lekérdezését az objektumészlelési előrejelzésekhez. |
ImagePrediction | Ez az osztály egyetlen objektum előrejelzését határozza meg egyetlen képen. Tartalmazza az objektum azonosítójának és nevének tulajdonságait, az objektum határolókeretének helyét és a megbízhatósági pontszámot. |
Kódpéldák
Ezek a kódrészletek bemutatják, hogyan végezheti el a következő feladatokat a Java Custom Vision ügyfélkódtárával:
- Az ügyfél hitelesítése
- Új Custom Vision-projekt létrehozása
- Címkék hozzáadása a projekthez
- Képek feltöltése és címkézése
- A projekt betanítása
- Az aktuális iteráció közzététele
- Az előrejelzési végpont tesztelése
Az ügyfél hitelesítése
A fő módszerben példányosíthatja a betanítási és előrejelzési ügyfeleket a végpont és a kulcsok használatával.
// Authenticate
CustomVisionTrainingClient trainClient = CustomVisionTrainingManager
.authenticate(trainingEndpoint, trainingApiKey)
.withEndpoint(trainingEndpoint);
CustomVisionPredictionClient predictor = CustomVisionPredictionManager
.authenticate(predictionEndpoint, predictionApiKey)
.withEndpoint(predictionEndpoint);
Új Custom Vision-projekt létrehozása
Ez a következő metódus létrehoz egy objektumészlelési projektet. A létrehozott projekt a Custom Vision webhelyén jelenik meg, amelyet korábban felkeresett. Tekintse meg a CreateProject metódus túlterheléseit, és adjon meg más lehetőségeket a projekt létrehozásakor (erről a Detektor létrehozása webes portál útmutatójában olvashat).
public static Project createProjectOD(CustomVisionTrainingClient trainClient) {
Trainings trainer = trainClient.trainings();
// find the object detection domain to set the project type
Domain objectDetectionDomain = null;
List<Domain> domains = trainer.getDomains();
for (final Domain domain : domains) {
if (domain.type() == DomainType.OBJECT_DETECTION) {
objectDetectionDomain = domain;
break;
}
}
if (objectDetectionDomain == null) {
System.out.println("Unexpected result; no objects were detected.");
}
System.out.println("Creating project...");
// create an object detection project
Project project = trainer.createProject().withName("Sample Java OD Project")
.withDescription("Sample OD Project").withDomainId(objectDetectionDomain.id())
.withClassificationType(Classifier.MULTILABEL.toString()).execute();
return project;
}
Címkék hozzáadása a projekthez
Ez a módszer határozza meg a modell betanítása során használni kívánt címkéket.
public static void addTagsOD(CustomVisionTrainingClient trainClient, Project project) {
Trainings trainer = trainClient.trainings();
// create fork tag
Tag forkTag = trainer.createTag().withProjectId(project.id()).withName("fork").execute();
// create scissors tag
Tag scissorsTag = trainer.createTag().withProjectId(project.id()).withName("scissor").execute();
}
Képek feltöltése és címkézése
Először töltse le a projekt mintaképét. Mentse a Mintaképek mappa tartalmát a helyi eszközre.
Feljegyzés
Több képre van szüksége a betanítás elvégzéséhez? A Trove, a Microsoft Garage projekt lehetővé teszi, hogy betanítás céljából képeket gyűjtsön és vásároljon. Miután összegyűjtötte a képeket, letöltheti őket, majd a szokásos módon importálhatja őket a Custom Vision-projektbe. További információért látogasson el a Trove oldalra .
Ha képeket címkéz meg az objektumészlelési projektekben, meg kell adnia a címkével ellátott objektumok régióját a normalizált koordináták használatával. Az alábbi kód a címkével ellátott régiójához társítja mindegyik mintaképet.
Feljegyzés
Ha nem rendelkezik kattintással és húzással a régiók koordinátáinak megjelöléséhez, használhatja a webes felhasználói felületet a Customvision.ai. Ebben a példában a koordináták már meg vannak adva.
public static void uploadImagesOD(CustomVisionTrainingClient trainClient, Project project) {
// Mapping of filenames to their respective regions in the image. The
// coordinates are specified
// as left, top, width, height in normalized coordinates. I.e. (left is left in
// pixels / width in pixels)
// This is a hardcoded mapping of the files we'll upload along with the bounding
// box of the object in the
// image. The boudning box is specified as left, top, width, height in
// normalized coordinates.
// Normalized Left = Left / Width (in Pixels)
// Normalized Top = Top / Height (in Pixels)
// Normalized Bounding Box Width = (Right - Left) / Width (in Pixels)
// Normalized Bounding Box Height = (Bottom - Top) / Height (in Pixels)
HashMap<String, double[]> regionMap = new HashMap<String, double[]>();
regionMap.put("scissors_1.jpg", new double[] { 0.4007353, 0.194068655, 0.259803921, 0.6617647 });
regionMap.put("scissors_2.jpg", new double[] { 0.426470578, 0.185898721, 0.172794119, 0.5539216 });
regionMap.put("scissors_3.jpg", new double[] { 0.289215684, 0.259428144, 0.403186262, 0.421568632 });
regionMap.put("scissors_4.jpg", new double[] { 0.343137264, 0.105833367, 0.332107842, 0.8055556 });
regionMap.put("scissors_5.jpg", new double[] { 0.3125, 0.09766343, 0.435049027, 0.71405226 });
regionMap.put("scissors_6.jpg", new double[] { 0.379901975, 0.24308826, 0.32107842, 0.5718954 });
regionMap.put("scissors_7.jpg", new double[] { 0.341911763, 0.20714055, 0.3137255, 0.6356209 });
regionMap.put("scissors_8.jpg", new double[] { 0.231617644, 0.08459154, 0.504901946, 0.8480392 });
regionMap.put("scissors_9.jpg", new double[] { 0.170343131, 0.332957536, 0.767156839, 0.403594762 });
regionMap.put("scissors_10.jpg", new double[] { 0.204656869, 0.120539248, 0.5245098, 0.743464053 });
regionMap.put("scissors_11.jpg", new double[] { 0.05514706, 0.159754932, 0.799019635, 0.730392158 });
regionMap.put("scissors_12.jpg", new double[] { 0.265931368, 0.169558853, 0.5061275, 0.606209159 });
regionMap.put("scissors_13.jpg", new double[] { 0.241421565, 0.184264734, 0.448529422, 0.6830065 });
regionMap.put("scissors_14.jpg", new double[] { 0.05759804, 0.05027781, 0.75, 0.882352948 });
regionMap.put("scissors_15.jpg", new double[] { 0.191176474, 0.169558853, 0.6936275, 0.6748366 });
regionMap.put("scissors_16.jpg", new double[] { 0.1004902, 0.279036, 0.6911765, 0.477124184 });
regionMap.put("scissors_17.jpg", new double[] { 0.2720588, 0.131977156, 0.4987745, 0.6911765 });
regionMap.put("scissors_18.jpg", new double[] { 0.180147052, 0.112369314, 0.6262255, 0.6666667 });
regionMap.put("scissors_19.jpg", new double[] { 0.333333343, 0.0274019931, 0.443627447, 0.852941155 });
regionMap.put("scissors_20.jpg", new double[] { 0.158088237, 0.04047389, 0.6691176, 0.843137264 });
regionMap.put("fork_1.jpg", new double[] { 0.145833328, 0.3509314, 0.5894608, 0.238562092 });
regionMap.put("fork_2.jpg", new double[] { 0.294117659, 0.216944471, 0.534313738, 0.5980392 });
regionMap.put("fork_3.jpg", new double[] { 0.09191177, 0.0682516545, 0.757352948, 0.6143791 });
regionMap.put("fork_4.jpg", new double[] { 0.254901975, 0.185898721, 0.5232843, 0.594771266 });
regionMap.put("fork_5.jpg", new double[] { 0.2365196, 0.128709182, 0.5845588, 0.71405226 });
regionMap.put("fork_6.jpg", new double[] { 0.115196079, 0.133611143, 0.676470637, 0.6993464 });
regionMap.put("fork_7.jpg", new double[] { 0.164215669, 0.31008172, 0.767156839, 0.410130739 });
regionMap.put("fork_8.jpg", new double[] { 0.118872553, 0.318251669, 0.817401946, 0.225490168 });
regionMap.put("fork_9.jpg", new double[] { 0.18259804, 0.2136765, 0.6335784, 0.643790841 });
regionMap.put("fork_10.jpg", new double[] { 0.05269608, 0.282303959, 0.8088235, 0.452614367 });
regionMap.put("fork_11.jpg", new double[] { 0.05759804, 0.0894935, 0.9007353, 0.3251634 });
regionMap.put("fork_12.jpg", new double[] { 0.3345588, 0.07315363, 0.375, 0.9150327 });
regionMap.put("fork_13.jpg", new double[] { 0.269607842, 0.194068655, 0.4093137, 0.6732026 });
regionMap.put("fork_14.jpg", new double[] { 0.143382356, 0.218578458, 0.7977941, 0.295751631 });
regionMap.put("fork_15.jpg", new double[] { 0.19240196, 0.0633497, 0.5710784, 0.8398692 });
regionMap.put("fork_16.jpg", new double[] { 0.140931368, 0.480016381, 0.6838235, 0.240196079 });
regionMap.put("fork_17.jpg", new double[] { 0.305147052, 0.2512582, 0.4791667, 0.5408496 });
regionMap.put("fork_18.jpg", new double[] { 0.234068632, 0.445702642, 0.6127451, 0.344771236 });
regionMap.put("fork_19.jpg", new double[] { 0.219362751, 0.141781077, 0.5919118, 0.6683006 });
regionMap.put("fork_20.jpg", new double[] { 0.180147052, 0.239820287, 0.6887255, 0.235294119 });
A következő kódblokk hozzáadja a képeket a projekthez. Módosítania kell a hívások argumentumaitGetImage
, hogy a letöltött elágazás- és ollómappák helyére mutasson.
Trainings trainer = trainClient.trainings();
System.out.println("Adding images...");
for (int i = 1; i <= 20; i++) {
String fileName = "fork_" + i + ".jpg";
byte[] contents = GetImage("/fork", fileName);
AddImageToProject(trainer, project, fileName, contents, forkTag.id(), regionMap.get(fileName));
}
for (int i = 1; i <= 20; i++) {
String fileName = "scissors_" + i + ".jpg";
byte[] contents = GetImage("/scissors", fileName);
AddImageToProject(trainer, project, fileName, contents, scissorsTag.id(), regionMap.get(fileName));
}
}
Az előző kódrészlet két segédfüggvényt használ, amelyek erőforrás-adatfolyamként kérik le a képeket, és feltöltik őket a szolgáltatásba (egyetlen kötegben legfeljebb 64 képet tölthet fel). Definiálja ezeket a metódusokat.
private static void AddImageToProject(Trainings trainer, Project project, String fileName, byte[] contents,
UUID tag, double[] regionValues) {
System.out.println("Adding image: " + fileName);
ImageFileCreateEntry file = new ImageFileCreateEntry().withName(fileName).withContents(contents);
ImageFileCreateBatch batch = new ImageFileCreateBatch().withImages(Collections.singletonList(file));
// If Optional region is specified, tack it on and place the tag there,
// otherwise
// add it to the batch.
if (regionValues != null) {
Region region = new Region().withTagId(tag).withLeft(regionValues[0]).withTop(regionValues[1])
.withWidth(regionValues[2]).withHeight(regionValues[3]);
file = file.withRegions(Collections.singletonList(region));
} else {
batch = batch.withTagIds(Collections.singletonList(tag));
}
trainer.createImagesFromFiles(project.id(), batch);
}
private static byte[] GetImage(String folder, String fileName) {
try {
return ByteStreams.toByteArray(CustomVisionSamples.class.getResourceAsStream(folder + "/" + fileName));
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
return null;
}
A projekt tanítása
Ez a módszer hozza létre az első betanítási iterációt a projektben. A betanítás befejezéséig lekérdezi a szolgáltatást.
public static String trainProjectOD(CustomVisionTrainingClient trainClient, Project project) {
Trainings trainer = trainClient.trainings();
System.out.println("Training...");
Iteration iteration = trainer.trainProject(project.id(), new TrainProjectOptionalParameter());
while (iteration.status().equals("Training")) {
System.out.println("Training Status: " + iteration.status());
Thread.sleep(5000);
iteration = trainer.getIteration(project.id(), iteration.id());
}
System.out.println("Training Status: " + iteration.status());
}
Az aktuális iteráció közzététele
Ezzel a módszerrel a modell aktuális iterációja elérhető lesz a lekérdezéshez. A modell neve hivatkozásként használható előrejelzési kérések küldéséhez. Meg kell adnia a saját értékét a következőhöz predictionResourceId
: . Az előrejelzési erőforrás-azonosítót az Azure Portal Tulajdonságok lapján találja, erőforrás-azonosítóként felsorolva.
public static String publishIterationOD(CustomVisionTrainingClient trainClient, Project project) {
Trainings trainer = trainClient.trainings();
// The iteration is now trained. Publish it to the prediction endpoint.
String publishedModelName = "myModel";
String predictionID = "<your-prediction-resource-ID>";
trainer.publishIteration(project.id(), iteration.id(), publishedModelName, predictionID);
return publishedModelName;
}
Az előrejelzési végpont tesztelése
Ez a metódus betölti a tesztrendszerképet, lekérdezi a modell végpontját, és előrejelzési adatokat ad ki a konzolon.
public static void testProjectOD(CustomVisionPredictionClient predictor, Project project) {
// load test image
byte[] testImage = GetImage("/ObjectTest", "test_image.jpg");
// predict
ImagePrediction results = predictor.predictions().detectImage().withProjectId(project.id())
.withPublishedName(publishedModelName).withImageData(testImage).execute();
for (Prediction prediction : results.predictions()) {
System.out.println(String.format("\t%s: %.2f%% at: %.2f, %.2f, %.2f, %.2f", prediction.tagName(),
prediction.probability() * 100.0f, prediction.boundingBox().left(), prediction.boundingBox().top(),
prediction.boundingBox().width(), prediction.boundingBox().height()));
}
}
Az alkalmazás futtatása
Az alkalmazást a következőkkel hozhatja létre:
gradle build
Futtassa az alkalmazást a gradle run
következő paranccsal:
gradle run
Az erőforrások eltávolítása
Ha törölni és eltávolítani szeretne egy Azure AI-szolgáltatási előfizetést, törölheti az erőforrást vagy az erőforráscsoportot. Az erőforráscsoport törlése a hozzá társított egyéb erőforrásokat is törli.
Ha saját objektumészlelési projektet szeretne megvalósítani (vagy ehelyett egy képosztályozási projektet szeretne kipróbálni), érdemes törölnie a példából a villa-/ollóészlelési projektet. Az ingyenes előfizetés két Custom Vision-projektet tesz lehetővé.
A Custom Vision webhelyén lépjen a projektekhez, és kattintson a My New Project panel alsó részén található kuka ikonra.
Következő lépések
Most elvégezte az objektumészlelési folyamat minden lépését a kódban. Ez a minta egyetlen betanítási iterációt hajt végre, de gyakran többször kell betanítania és tesztelnie a modellt, hogy pontosabb legyen. Az alábbi útmutató a képosztályozással foglalkozik, az alapelvei azonban hasonlóak az objektumészlelés alapelveihez.
- Mi az a Custom Vision?
- A minta forráskódja a GitHubon található
Ez az útmutató útmutatást és mintakódot biztosít a Custom Vision ügyfélkódtár Node.js objektumészlelési modell létrehozásához való használatának megkezdéséhez. Létrehoz egy projektet, címkéket ad hozzá, betanítja a projektet, és a projekt előrejelzési végpontJÁNAK URL-címével programozott módon teszteli azt. Ezt a példát használhatja sablonként saját képfelismerő alkalmazás létrehozásához.
Feljegyzés
Ha kód írása nélkül szeretne objektumészlelési modellt készíteni és betaníteni, tekintse meg inkább a böngészőalapú útmutatást.
A .NET-hez készült Custom Vision ügyfélkódtár használatával:
- Új Custom Vision-projekt létrehozása
- Címkék hozzáadása a projekthez
- Képek feltöltése és címkézése
- A projekt tanítása
- Az aktuális iteráció közzététele
- Az előrejelzési végpont tesztelése
Referenciadokumentáció (képzés)(előrejelzés) | Kódtár forráskódja (betanítás)(előrejelzés) | Csomag (npm) (betanítás)(előrejelzés) | Minták
Előfeltételek
- Azure-előfizetés – Ingyenes létrehozás
- A Node.js aktuális verziója
- Miután megkapta az Azure-előfizetését, hozzon létre egy Custom Vision-erőforrást az Azure Portalon egy betanítási és előrejelzési erőforrás létrehozásához.
- Az ingyenes tarifacsomag (
F0
) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben.
- Az ingyenes tarifacsomag (
Környezeti változók létrehozása
Ebben a példában a hitelesítő adatokat az alkalmazást futtató helyi gépen lévő környezeti változókba fogja írni.
Nyissa meg az Azure Portalt. Ha az Előfeltételek szakaszban létrehozott Custom Vision-erőforrások sikeresen üzembe helyezve, válassza az Erőforrás megnyitása gombot a Következő lépések csoportban. A kulcsokat és végpontokat az erőforrások kulcs- és végpontoldalain, az erőforrás-kezelés alatt találja. Be kell szereznie a betanítási és előrejelzési erőforrások kulcsait, valamint az API-végpontokat.
Az előrejelzési erőforrás-azonosítót az előrejelzési erőforrás Tulajdonságok lapján találja az Azure Portalon, erőforrás-azonosítóként felsorolva.
Tipp.
Ezeket az értékeket is lekérheti https://www.customvision.ai/ . Bejelentkezés után kattintson a jobb felső sarokban található Gépház ikonra. A Beállítás lapon megtekintheti az összes kulcsot, erőforrás-azonosítót és végpontot.
Figyelem
Ne vegye fel közvetlenül a kulcsot a kódba, és soha ne tegye közzé nyilvánosan. Az Azure AI-szolgáltatások biztonsági cikkében további hitelesítési lehetőségeket talál, például az Azure Key Vaultot.
A környezeti változók beállításához nyisson meg egy konzolablakot, és kövesse az operációs rendszer és a fejlesztési környezet utasításait.
- A
VISION_TRAINING KEY
környezeti változó beállításához cserélje leyour-training-key
a betanítási erőforrás egyik kulcsára. - A
VISION_TRAINING_ENDPOINT
környezeti változó beállításához cserélje leyour-training-endpoint
a betanítási erőforrás végpontját. - A
VISION_PREDICTION_KEY
környezeti változó beállításához cserélje leyour-prediction-key
az előrejelzési erőforrás egyik kulcsára. - A
VISION_PREDICTION_ENDPOINT
környezeti változó beállításához cserélje leyour-prediction-endpoint
az előrejelzési erőforrás végpontját. - A
VISION_PREDICTION_RESOURCE_ID
környezeti változó beállításához cserélje leyour-resource-id
az előrejelzési erőforrás erőforrás-azonosítóját.
setx VISION_TRAINING_KEY your-training-key
setx VISION_TRAINING_ENDPOINT your-training-endpoint
setx VISION_PREDICTION_KEY your-prediction-key
setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint
setx VISION_PREDICTION_RESOURCE_ID your-resource-id
A környezeti változók hozzáadása után előfordulhat, hogy újra kell indítania a futó programokat, amelyek felolvassák a környezeti változókat, beleértve a konzolablakot is.
Beállítás
Új Node.js-alkalmazás létrehozása
Egy konzolablakban (pl. cmd, PowerShell vagy Bash) hozzon létre egy új mappát az alkalmazásnak, majd navigáljon oda.
mkdir myapp && cd myapp
Futtassa az npm init
parancsot egy Node-alkalmazás package.json
fájllal való létrehozásához.
npm init
Telepítse az ügyfélkódtárat
Ha képelemzési alkalmazást szeretne írni a Custom Vision for Node.js használatával, szüksége lesz a Custom Vision NPM-csomagokra. A telepítésükhöz futtassa a következő parancsot a PowerShellben:
npm install @azure/cognitiveservices-customvision-training
npm install @azure/cognitiveservices-customvision-prediction
Az alkalmazás package.json
fájlja frissül a függőségekkel.
Hozzon létre egy elnevezett index.js
fájlt, és importálja a következő kódtárakat:
const util = require('util');
const fs = require('fs');
const TrainingApi = require("@azure/cognitiveservices-customvision-training");
const PredictionApi = require("@azure/cognitiveservices-customvision-prediction");
const msRest = require("@azure/ms-rest-js");
Tipp.
Szeretné egyben megtekinteni a teljes gyorsútmutatós kódfájlt? Megtalálhatja a GitHubon, amely a gyorsútmutató kódmintáit is tartalmazza.
Változókat hozhat létre az erőforrás Azure-végpontjához és kulcsaihoz.
// retrieve environment variables
const trainingKey = process.env["VISION_TRAINING_KEY"];
const trainingEndpoint = process.env["VISION_TRAINING_ENDPOINT"];
const predictionKey = process.env["VISION_PREDICTION_KEY"];
const predictionResourceId = process.env["VISION_PREDICTION_RESOURCE_ID"];
const predictionEndpoint = process.env["VISION_PREDICTION_ENDPOINT"];
Adjon hozzá mezőket a projekt nevének és egy időtúllépési paraméternek az aszinkron hívásokhoz.
const publishIterationName = "detectModel";
const setTimeoutPromise = util.promisify(setTimeout);
Objektummodell
Név | Leírás |
---|---|
TrainingAPIClient | Ez az osztály kezeli a modellek létrehozását, betanítását és közzétételét. |
PredictionAPIClient | Ez az osztály kezeli a modellek lekérdezését az objektumészlelési előrejelzésekhez. |
előrejelzés | Ez a felület egyetlen előrejelzést határoz meg egyetlen képen. Tartalmazza az objektumazonosító és -név tulajdonságait, valamint egy megbízhatósági pontszámot. |
Kódpéldák
Ezek a kódrészletek bemutatják, hogyan végezheti el a következő feladatokat a JavaScripthez készült Custom Vision ügyfélkódtárral:
- Az ügyfél hitelesítése
- Új Custom Vision-projekt létrehozása
- Címkék hozzáadása a projekthez
- Képek feltöltése és címkézése
- A projekt betanítása
- Az aktuális iteráció közzététele
- Az előrejelzési végpont tesztelése
Az ügyfél hitelesítése
Ügyfélobjektumok példányosítása a végponttal és a kulccsal. Hozzon létre egy ApiKeyCredentials objektumot a kulccsal, és használja a végponttal egy TrainingAPIClient és PredictionAPIClient objektum létrehozásához.
const credentials = new msRest.ApiKeyCredentials({ inHeader: { "Training-key": trainingKey } });
const trainer = new TrainingApi.TrainingAPIClient(credentials, trainingEndpoint);
const predictor_credentials = new msRest.ApiKeyCredentials({ inHeader: { "Prediction-key": predictionKey } });
const predictor = new PredictionApi.PredictionAPIClient(predictor_credentials, predictionEndpoint);
Segédfüggvény hozzáadása
Adja hozzá a következő függvényt több aszinkron hívás indításához. Ezt később fogja használni.
const credentials = new msRest.ApiKeyCredentials({ inHeader: { "Training-key": trainingKey } });
const trainer = new TrainingApi.TrainingAPIClient(credentials, trainingEndpoint);
const predictor_credentials = new msRest.ApiKeyCredentials({ inHeader: { "Prediction-key": predictionKey } });
const predictor = new PredictionApi.PredictionAPIClient(predictor_credentials, predictionEndpoint);
Új Custom Vision-projekt létrehozása
Új függvény indítása az összes Custom Vision-függvényhívást tartalmazó függvényhez. Adja hozzá a következő kódot egy új Custom Vision service-projekt létrehozásához.
(async () => {
console.log("Creating project...");
const domains = await trainer.getDomains()
const objDetectDomain = domains.find(domain => domain.type === "ObjectDetection");
const sampleProject = await trainer.createProject("Sample Obj Detection Project", { domainId: objDetectDomain.id });
Címkék hozzáadása a projekthez
Ha besorolási címkéket szeretne létrehozni a projekthez, adja hozzá a következő kódot a függvényhez:
const forkTag = await trainer.createTag(sampleProject.id, "Fork");
const scissorsTag = await trainer.createTag(sampleProject.id, "Scissors");
Képek feltöltése és címkézése
Először töltse le a projekt mintaképét. Mentse a Mintaképek mappa tartalmát a helyi eszközre.
A minta képek projekthez adásához, helyezze el a következő kódot a címke létrehozása után. Ez a kód a képeket a hozzájuk tartozó címkékkel együtt tölti fel. Ha képeket címkéz meg az objektumészlelési projektekben, meg kell adnia a címkével ellátott objektumok régióját a normalizált koordináták használatával. Ebben az oktatóanyagban a régiók a kóddal beágyazottan vannak kódolva. A régiók normalizált koordinátákban adják meg a határolókeretet, és a következő sorrendben adják meg a koordinátákat: bal oldali, felső, szélesség, magasság. Egyetlen kötegben legfeljebb 64 képet tölthet fel.
const sampleDataRoot = "Images";
const forkImageRegions = {
"fork_1.jpg": [0.145833328, 0.3509314, 0.5894608, 0.238562092],
"fork_2.jpg": [0.294117659, 0.216944471, 0.534313738, 0.5980392],
"fork_3.jpg": [0.09191177, 0.0682516545, 0.757352948, 0.6143791],
"fork_4.jpg": [0.254901975, 0.185898721, 0.5232843, 0.594771266],
"fork_5.jpg": [0.2365196, 0.128709182, 0.5845588, 0.71405226],
"fork_6.jpg": [0.115196079, 0.133611143, 0.676470637, 0.6993464],
"fork_7.jpg": [0.164215669, 0.31008172, 0.767156839, 0.410130739],
"fork_8.jpg": [0.118872553, 0.318251669, 0.817401946, 0.225490168],
"fork_9.jpg": [0.18259804, 0.2136765, 0.6335784, 0.643790841],
"fork_10.jpg": [0.05269608, 0.282303959, 0.8088235, 0.452614367],
"fork_11.jpg": [0.05759804, 0.0894935, 0.9007353, 0.3251634],
"fork_12.jpg": [0.3345588, 0.07315363, 0.375, 0.9150327],
"fork_13.jpg": [0.269607842, 0.194068655, 0.4093137, 0.6732026],
"fork_14.jpg": [0.143382356, 0.218578458, 0.7977941, 0.295751631],
"fork_15.jpg": [0.19240196, 0.0633497, 0.5710784, 0.8398692],
"fork_16.jpg": [0.140931368, 0.480016381, 0.6838235, 0.240196079],
"fork_17.jpg": [0.305147052, 0.2512582, 0.4791667, 0.5408496],
"fork_18.jpg": [0.234068632, 0.445702642, 0.6127451, 0.344771236],
"fork_19.jpg": [0.219362751, 0.141781077, 0.5919118, 0.6683006],
"fork_20.jpg": [0.180147052, 0.239820287, 0.6887255, 0.235294119]
};
const scissorsImageRegions = {
"scissors_1.jpg": [0.4007353, 0.194068655, 0.259803921, 0.6617647],
"scissors_2.jpg": [0.426470578, 0.185898721, 0.172794119, 0.5539216],
"scissors_3.jpg": [0.289215684, 0.259428144, 0.403186262, 0.421568632],
"scissors_4.jpg": [0.343137264, 0.105833367, 0.332107842, 0.8055556],
"scissors_5.jpg": [0.3125, 0.09766343, 0.435049027, 0.71405226],
"scissors_6.jpg": [0.379901975, 0.24308826, 0.32107842, 0.5718954],
"scissors_7.jpg": [0.341911763, 0.20714055, 0.3137255, 0.6356209],
"scissors_8.jpg": [0.231617644, 0.08459154, 0.504901946, 0.8480392],
"scissors_9.jpg": [0.170343131, 0.332957536, 0.767156839, 0.403594762],
"scissors_10.jpg": [0.204656869, 0.120539248, 0.5245098, 0.743464053],
"scissors_11.jpg": [0.05514706, 0.159754932, 0.799019635, 0.730392158],
"scissors_12.jpg": [0.265931368, 0.169558853, 0.5061275, 0.606209159],
"scissors_13.jpg": [0.241421565, 0.184264734, 0.448529422, 0.6830065],
"scissors_14.jpg": [0.05759804, 0.05027781, 0.75, 0.882352948],
"scissors_15.jpg": [0.191176474, 0.169558853, 0.6936275, 0.6748366],
"scissors_16.jpg": [0.1004902, 0.279036, 0.6911765, 0.477124184],
"scissors_17.jpg": [0.2720588, 0.131977156, 0.4987745, 0.6911765],
"scissors_18.jpg": [0.180147052, 0.112369314, 0.6262255, 0.6666667],
"scissors_19.jpg": [0.333333343, 0.0274019931, 0.443627447, 0.852941155],
"scissors_20.jpg": [0.158088237, 0.04047389, 0.6691176, 0.843137264]
};
console.log("Adding images...");
let fileUploadPromises = [];
const forkDir = `${sampleDataRoot}/fork`;
const forkFiles = fs.readdirSync(forkDir);
await asyncForEach(forkFiles, async (file) => {
const region = { tagId: forkTag.id, left: forkImageRegions[file][0], top: forkImageRegions[file][1], width: forkImageRegions[file][2], height: forkImageRegions[file][3] };
const entry = { name: file, contents: fs.readFileSync(`${forkDir}/${file}`), regions: [region] };
const batch = { images: [entry] };
// Wait one second to accommodate rate limit.
await setTimeoutPromise(1000, null);
fileUploadPromises.push(trainer.createImagesFromFiles(sampleProject.id, batch));
});
const scissorsDir = `${sampleDataRoot}/scissors`;
const scissorsFiles = fs.readdirSync(scissorsDir);
await asyncForEach(scissorsFiles, async (file) => {
const region = { tagId: scissorsTag.id, left: scissorsImageRegions[file][0], top: scissorsImageRegions[file][1], width: scissorsImageRegions[file][2], height: scissorsImageRegions[file][3] };
const entry = { name: file, contents: fs.readFileSync(`${scissorsDir}/${file}`), regions: [region] };
const batch = { images: [entry] };
// Wait one second to accommodate rate limit.
await setTimeoutPromise(1000, null);
fileUploadPromises.push(trainer.createImagesFromFiles(sampleProject.id, batch));
});
await Promise.all(fileUploadPromises);
Fontos
Módosítania kell a rendszerképek elérési útját (sampleDataRoot
) az Azure AI-szolgáltatások Python SDK-minták adattárának letöltési helye alapján.
Feljegyzés
Ha nem rendelkezik kattintással és húzással a régiók koordinátáinak megjelöléséhez, használhatja a webes felhasználói felületet a Customvision.ai. Ebben a példában a koordináták már meg vannak adva.
A projekt tanítása
Ez a kód létrehozza az előrejelzési modell első iterációját.
console.log("Training...");
let trainingIteration = await trainer.trainProject(sampleProject.id);
// Wait for training to complete
console.log("Training started...");
while (trainingIteration.status == "Training") {
console.log("Training status: " + trainingIteration.status);
// wait for ten seconds
await setTimeoutPromise(10000, null);
trainingIteration = await trainer.getIteration(sampleProject.id, trainingIteration.id)
}
console.log("Training status: " + trainingIteration.status);
Az aktuális iteráció közzététele
Ez a kód közzéteszi a betanított iterációt az előrejelzési végponton. A közzétett iterációnak megadott név használható előrejelzési kérések küldéséhez. Az előrejelzési végponton csak a közzététel után érhető el iteráció.
// Publish the iteration to the end point
await trainer.publishIteration(sampleProject.id, trainingIteration.id, publishIterationName, predictionResourceId);
Az előrejelzési végpont tesztelése
Ha képet szeretne küldeni az előrejelzési végpontnak, és le szeretné kérni az előrejelzést, adja hozzá a következő kódot a függvényhez.
const testFile = fs.readFileSync(`${sampleDataRoot}/test/test_image.jpg`);
const results = await predictor.detectImage(sampleProject.id, publishIterationName, testFile)
// Show results
console.log("Results:");
results.predictions.forEach(predictedResult => {
console.log(`\t ${predictedResult.tagName}: ${(predictedResult.probability * 100.0).toFixed(2)}% ${predictedResult.boundingBox.left},${predictedResult.boundingBox.top},${predictedResult.boundingBox.width},${predictedResult.boundingBox.height}`);
});
Ezután zárja be a Custom Vision függvényt, és hívja meg.
})()
Az alkalmazás futtatása
Futtassa az alkalmazást a node
paranccsal a gyorsútmutatós fájlon.
node index.js
Az alkalmazás kimenetének meg kell jelennie a konzolon. Ezután ellenőrizheti, hogy a tesztrendszerkép (a <sampleDataRoot>/Test/) megfelelően van-e megjelölve, és hogy az észlelési régió helyes-e. Vissza is léphet a Custom Vision webhelyére, és megtekintheti az újonnan létrehozott projekt aktuális állapotát.
Az erőforrások eltávolítása
Ha saját objektumészlelési projektet szeretne megvalósítani (vagy ehelyett egy képosztályozási projektet szeretne kipróbálni), érdemes törölnie a példából a villa-/ollóészlelési projektet. Az ingyenes előfizetés két Custom Vision-projektet tesz lehetővé.
A Custom Vision webhelyén lépjen a projektekhez, és kattintson a My New Project panel alsó részén található kuka ikonra.
Következő lépések
Most elvégezte az objektumészlelési folyamat minden lépését a kódban. Ez a minta egyetlen betanítási iterációt hajt végre, de gyakran többször kell betanítania és tesztelnie a modellt, hogy pontosabb legyen. Az alábbi útmutató a képosztályozással foglalkozik, az alapelvei azonban hasonlóak az objektumészlelés alapelveihez.
- Mi az a Custom Vision?
- A minta forráskódja a GitHubon található
- SDK-referenciadokumentáció (oktatás)
- SDK-referenciadokumentáció (előrejelzés)
Ismerkedés a Python Custom Vision ügyfélkódtárával. Az alábbi lépések végrehajtásával telepítheti a csomagot, és kipróbálhatja az objektumészlelési modell létrehozásához használt példakódot. Létrehoz egy projektet, címkéket ad hozzá, betanítja a projektet, és a projekt előrejelzési végpontJÁNAK URL-címével programozott módon teszteli azt. Ezt a példát használhatja sablonként saját képfelismerő alkalmazás létrehozásához.
Feljegyzés
Ha kód írása nélkül szeretne objektumészlelési modellt készíteni és betaníteni, tekintse meg inkább a böngészőalapú útmutatást.
A Python Custom Vision ügyfélkódtárával a következő célokra használhatja:
- Új Custom Vision-projekt létrehozása
- Címkék hozzáadása a projekthez
- Képek feltöltése és címkézése
- A projekt tanítása
- Az aktuális iteráció közzététele
- Az előrejelzési végpont tesztelése
Referenciadokumentáció Kódtár forráskódcsomagja | (PyPI)Minták | |
Előfeltételek
- Azure-előfizetés – Ingyenes létrehozás
- Python 3.x
- Miután megkapta az Azure-előfizetését, hozzon létre egy Custom Vision-erőforrást az Azure Portalon egy betanítási és előrejelzési erőforrás létrehozásához.
- Az ingyenes tarifacsomag (
F0
) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben.
- Az ingyenes tarifacsomag (
Környezeti változók létrehozása
Ebben a példában a hitelesítő adatokat az alkalmazást futtató helyi gépen lévő környezeti változókba fogja írni.
Nyissa meg az Azure Portalt. Ha az Előfeltételek szakaszban létrehozott Custom Vision-erőforrások sikeresen üzembe helyezve, válassza az Erőforrás megnyitása gombot a Következő lépések csoportban. A kulcsokat és végpontokat az erőforrások kulcs- és végpontoldalain, az erőforrás-kezelés alatt találja. Be kell szereznie a betanítási és előrejelzési erőforrások kulcsait, valamint az API-végpontokat.
Az előrejelzési erőforrás-azonosítót az előrejelzési erőforrás Tulajdonságok lapján találja az Azure Portalon, erőforrás-azonosítóként felsorolva.
Tipp.
Ezeket az értékeket is lekérheti https://www.customvision.ai/ . Bejelentkezés után kattintson a jobb felső sarokban található Gépház ikonra. A Beállítás lapon megtekintheti az összes kulcsot, erőforrás-azonosítót és végpontot.
Figyelem
Ne vegye fel közvetlenül a kulcsot a kódba, és soha ne tegye közzé nyilvánosan. Az Azure AI-szolgáltatások biztonsági cikkében további hitelesítési lehetőségeket talál, például az Azure Key Vaultot.
A környezeti változók beállításához nyisson meg egy konzolablakot, és kövesse az operációs rendszer és a fejlesztési környezet utasításait.
- A
VISION_TRAINING KEY
környezeti változó beállításához cserélje leyour-training-key
a betanítási erőforrás egyik kulcsára. - A
VISION_TRAINING_ENDPOINT
környezeti változó beállításához cserélje leyour-training-endpoint
a betanítási erőforrás végpontját. - A
VISION_PREDICTION_KEY
környezeti változó beállításához cserélje leyour-prediction-key
az előrejelzési erőforrás egyik kulcsára. - A
VISION_PREDICTION_ENDPOINT
környezeti változó beállításához cserélje leyour-prediction-endpoint
az előrejelzési erőforrás végpontját. - A
VISION_PREDICTION_RESOURCE_ID
környezeti változó beállításához cserélje leyour-resource-id
az előrejelzési erőforrás erőforrás-azonosítóját.
setx VISION_TRAINING_KEY your-training-key
setx VISION_TRAINING_ENDPOINT your-training-endpoint
setx VISION_PREDICTION_KEY your-prediction-key
setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint
setx VISION_PREDICTION_RESOURCE_ID your-resource-id
A környezeti változók hozzáadása után előfordulhat, hogy újra kell indítania a futó programokat, amelyek felolvassák a környezeti változókat, beleértve a konzolablakot is.
Beállítás
Telepítse az ügyfélkódtárat
Ha a Custom Vision for Pythonnal szeretne képelemzési alkalmazást írni, szüksége lesz a Custom Vision ügyfélkódtárára. A Python telepítése után futtassa a következő parancsot a PowerShellben vagy egy konzolablakban:
pip install azure-cognitiveservices-vision-customvision
Új Python-alkalmazás létrehozása
Hozzon létre egy új Python-fájlt, és importálja a következő kódtárakat.
from azure.cognitiveservices.vision.customvision.training import CustomVisionTrainingClient
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
from azure.cognitiveservices.vision.customvision.training.models import ImageFileCreateBatch, ImageFileCreateEntry, Region
from msrest.authentication import ApiKeyCredentials
import os, time, uuid
Tipp.
Szeretné egyben megtekinteni a teljes gyorsútmutatós kódfájlt? Megtalálhatja a GitHubon, amely a gyorsútmutató kódmintáit is tartalmazza.
Változókat hozhat létre az erőforrás Azure-végpontjához és kulcsaihoz.
# Replace with valid values
ENDPOINT = os.environ["VISION_TRAINING_ENDPOINT"]
training_key = os.environ["VISION_TRAINING_KEY"]
prediction_key = os.environ["VISION_PREDICTION_KEY"]
prediction_resource_id = os.environ["VISION_PREDICTION_RESOURCE_ID"]
Objektummodell
Név | Leírás |
---|---|
CustomVisionTrainingClient | Ez az osztály kezeli a modellek létrehozását, betanítását és közzétételét. |
CustomVisionPredictionClient | Ez az osztály kezeli a modellek lekérdezését az objektumészlelési előrejelzésekhez. |
ImagePrediction | Ez az osztály egyetlen objektum előrejelzését határozza meg egyetlen képen. Tartalmazza az objektum azonosítójának és nevének tulajdonságait, az objektum határolókeretének helyét és a megbízhatósági pontszámot. |
Kódpéldák
Ezek a kódrészletek bemutatják, hogyan végezheti el a következőket a Python Custom Vision ügyfélkódtárával:
- Az ügyfél hitelesítése
- Új Custom Vision-projekt létrehozása
- Címkék hozzáadása a projekthez
- Képek feltöltése és címkézése
- A projekt betanítása
- Az aktuális iteráció közzététele
- Az előrejelzési végpont tesztelése
Az ügyfél hitelesítése
Hozzon létre egy betanítási és előrejelzési ügyfelet a végponttal és a kulcsokkal. Hozzon létre ApiKeyServiceClientCredentials objektumokat a kulcsaival, és használja őket a végponttal a CustomVisionTrainingClient és a CustomVisionPredictionClient objektum létrehozásához.
credentials = ApiKeyCredentials(in_headers={"Training-key": training_key})
trainer = CustomVisionTrainingClient(ENDPOINT, credentials)
prediction_credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)
Új Custom Vision-projekt létrehozása
Adja hozzá a következő kódot a szkripthez egy új Custom Vision Service-projekt létrehozásához.
A projekt létrehozásakor a create_project metódussal további lehetőségeket is megadhat (ezt a detektorkészítés webes portál útmutatója ismerteti).
publish_iteration_name = "detectModel"
# Find the object detection domain
obj_detection_domain = next(domain for domain in trainer.get_domains() if domain.type == "ObjectDetection" and domain.name == "General")
# Create a new project
print ("Creating project...")
# Use uuid to avoid project name collisions.
project = trainer.create_project(str(uuid.uuid4()), domain_id=obj_detection_domain.id)
Címkék hozzáadása a projekthez
Ha objektumcímkéket szeretne létrehozni a projektben, adja hozzá a következő kódot:
# Make two tags in the new project
fork_tag = trainer.create_tag(project.id, "fork")
scissors_tag = trainer.create_tag(project.id, "scissors")
Képek feltöltése és címkézése
Először töltse le a projekt mintaképét. Mentse a Mintaképek mappa tartalmát a helyi eszközre.
Ha képeket címkéz meg az objektumészlelési projektekben, meg kell adnia a címkével ellátott objektumok régióját a normalizált koordináták használatával. Az alábbi kód a címkével ellátott régiójához társítja mindegyik mintaképet. A régiók normalizált koordinátákban adják meg a határolókeretet, és a következő sorrendben adják meg a koordinátákat: bal oldali, felső, szélesség, magasság.
fork_image_regions = {
"fork_1": [ 0.145833328, 0.3509314, 0.5894608, 0.238562092 ],
"fork_2": [ 0.294117659, 0.216944471, 0.534313738, 0.5980392 ],
"fork_3": [ 0.09191177, 0.0682516545, 0.757352948, 0.6143791 ],
"fork_4": [ 0.254901975, 0.185898721, 0.5232843, 0.594771266 ],
"fork_5": [ 0.2365196, 0.128709182, 0.5845588, 0.71405226 ],
"fork_6": [ 0.115196079, 0.133611143, 0.676470637, 0.6993464 ],
"fork_7": [ 0.164215669, 0.31008172, 0.767156839, 0.410130739 ],
"fork_8": [ 0.118872553, 0.318251669, 0.817401946, 0.225490168 ],
"fork_9": [ 0.18259804, 0.2136765, 0.6335784, 0.643790841 ],
"fork_10": [ 0.05269608, 0.282303959, 0.8088235, 0.452614367 ],
"fork_11": [ 0.05759804, 0.0894935, 0.9007353, 0.3251634 ],
"fork_12": [ 0.3345588, 0.07315363, 0.375, 0.9150327 ],
"fork_13": [ 0.269607842, 0.194068655, 0.4093137, 0.6732026 ],
"fork_14": [ 0.143382356, 0.218578458, 0.7977941, 0.295751631 ],
"fork_15": [ 0.19240196, 0.0633497, 0.5710784, 0.8398692 ],
"fork_16": [ 0.140931368, 0.480016381, 0.6838235, 0.240196079 ],
"fork_17": [ 0.305147052, 0.2512582, 0.4791667, 0.5408496 ],
"fork_18": [ 0.234068632, 0.445702642, 0.6127451, 0.344771236 ],
"fork_19": [ 0.219362751, 0.141781077, 0.5919118, 0.6683006 ],
"fork_20": [ 0.180147052, 0.239820287, 0.6887255, 0.235294119 ]
}
scissors_image_regions = {
"scissors_1": [ 0.4007353, 0.194068655, 0.259803921, 0.6617647 ],
"scissors_2": [ 0.426470578, 0.185898721, 0.172794119, 0.5539216 ],
"scissors_3": [ 0.289215684, 0.259428144, 0.403186262, 0.421568632 ],
"scissors_4": [ 0.343137264, 0.105833367, 0.332107842, 0.8055556 ],
"scissors_5": [ 0.3125, 0.09766343, 0.435049027, 0.71405226 ],
"scissors_6": [ 0.379901975, 0.24308826, 0.32107842, 0.5718954 ],
"scissors_7": [ 0.341911763, 0.20714055, 0.3137255, 0.6356209 ],
"scissors_8": [ 0.231617644, 0.08459154, 0.504901946, 0.8480392 ],
"scissors_9": [ 0.170343131, 0.332957536, 0.767156839, 0.403594762 ],
"scissors_10": [ 0.204656869, 0.120539248, 0.5245098, 0.743464053 ],
"scissors_11": [ 0.05514706, 0.159754932, 0.799019635, 0.730392158 ],
"scissors_12": [ 0.265931368, 0.169558853, 0.5061275, 0.606209159 ],
"scissors_13": [ 0.241421565, 0.184264734, 0.448529422, 0.6830065 ],
"scissors_14": [ 0.05759804, 0.05027781, 0.75, 0.882352948 ],
"scissors_15": [ 0.191176474, 0.169558853, 0.6936275, 0.6748366 ],
"scissors_16": [ 0.1004902, 0.279036, 0.6911765, 0.477124184 ],
"scissors_17": [ 0.2720588, 0.131977156, 0.4987745, 0.6911765 ],
"scissors_18": [ 0.180147052, 0.112369314, 0.6262255, 0.6666667 ],
"scissors_19": [ 0.333333343, 0.0274019931, 0.443627447, 0.852941155 ],
"scissors_20": [ 0.158088237, 0.04047389, 0.6691176, 0.843137264 ]
}
Feljegyzés
Ha nem rendelkezik kattintással és húzással a régiók koordinátáinak megjelöléséhez, használhatja a webes felhasználói felületet a Customvision.ai. Ebben a példában a koordináták már meg vannak adva.
Ezután használja ezt a társítástérképet az egyes mintaképek régiókoordinátáival való feltöltéséhez (egyetlen kötegben legfeljebb 64 képet tölthet fel). Adja hozzá a következő kódot.
base_image_location = os.path.join (os.path.dirname(__file__), "Images")
# Go through the data table above and create the images
print ("Adding images...")
tagged_images_with_regions = []
for file_name in fork_image_regions.keys():
x,y,w,h = fork_image_regions[file_name]
regions = [ Region(tag_id=fork_tag.id, left=x,top=y,width=w,height=h) ]
with open(os.path.join (base_image_location, "fork", file_name + ".jpg"), mode="rb") as image_contents:
tagged_images_with_regions.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), regions=regions))
for file_name in scissors_image_regions.keys():
x,y,w,h = scissors_image_regions[file_name]
regions = [ Region(tag_id=scissors_tag.id, left=x,top=y,width=w,height=h) ]
with open(os.path.join (base_image_location, "scissors", file_name + ".jpg"), mode="rb") as image_contents:
tagged_images_with_regions.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), regions=regions))
upload_result = trainer.create_images_from_files(project.id, ImageFileCreateBatch(images=tagged_images_with_regions))
if not upload_result.is_batch_successful:
print("Image batch upload failed.")
for image in upload_result.images:
print("Image status: ", image.status)
exit(-1)
Feljegyzés
Módosítania kell a rendszerképek elérési útját annak alapján, hogy hol töltötte le korábban az Azure AI-szolgáltatások Python SDK-mintáinak adattárát.
A projekt tanítása
Ez a kód létrehozza az előrejelzési modell első iterációját.
print ("Training...")
iteration = trainer.train_project(project.id)
while (iteration.status != "Completed"):
iteration = trainer.get_iteration(project.id, iteration.id)
print ("Training status: " + iteration.status)
time.sleep(1)
Tipp.
Betanítása kijelölt címkékkel
Igény szerint csak az alkalmazott címkék egy részhalmazára taníthat be. Ezt akkor érdemes megtennie, ha még nem alkalmazott elég címkét bizonyos címkék közül, de van elég más. A train_project hívásban állítsa a selected_tags opcionális paramétert a használni kívánt címkék azonosító sztringjeinek listájára. A modell betanítása csak a lista címkéinek felismerésére fog betanulni.
Az aktuális iteráció közzététele
Az előrejelzési végponton csak a közzététel után érhető el iteráció. Az alábbi kód a modell aktuális iterációját teszi elérhetővé lekérdezésre.
# The iteration is now trained. Publish it to the project endpoint
trainer.publish_iteration(project.id, iteration.id, publish_iteration_name, prediction_resource_id)
print ("Done!")
Az előrejelzési végpont tesztelése
A képek előrejelzési végpontra való küldéséhez és az előrejelzés lekéréséhez adja hozzá a következő kódot a fájl végéhez:
# Now there is a trained endpoint that can be used to make a prediction
# Open the sample image and get back the prediction results.
with open(os.path.join (base_image_location, "test", "test_image.jpg"), mode="rb") as test_data:
results = predictor.detect_image(project.id, publish_iteration_name, test_data)
# Display the results.
for prediction in results.predictions:
print("\t" + prediction.tag_name + ": {0:.2f}% bbox.left = {1:.2f}, bbox.top = {2:.2f}, bbox.width = {3:.2f}, bbox.height = {4:.2f}".format(prediction.probability * 100, prediction.bounding_box.left, prediction.bounding_box.top, prediction.bounding_box.width, prediction.bounding_box.height))
Az alkalmazás futtatása
Futtassa a CustomVisionQuickstart.py.
python CustomVisionQuickstart.py
Az alkalmazás kimenetének meg kell jelennie a konzolon. Ezután ellenőrizheti, hogy a tesztkép (base_image_location<>/images/Test) megfelelően van-e megjelölve, és hogy az észlelési régió helyes-e. Vissza is léphet a Custom Vision webhelyére, és megtekintheti az újonnan létrehozott projekt aktuális állapotát.
Az erőforrások eltávolítása
Ha saját objektumészlelési projektet szeretne megvalósítani (vagy ehelyett egy képosztályozási projektet szeretne kipróbálni), érdemes törölnie a példából a villa-/ollóészlelési projektet. Az ingyenes előfizetés két Custom Vision-projektet tesz lehetővé.
A Custom Vision webhelyén lépjen a projektekhez, és kattintson a My New Project panel alsó részén található kuka ikonra.
Következő lépések
Most elvégezte az objektumészlelési folyamat minden lépését a kódban. Ez a minta egyetlen betanítási iterációt hajt végre, de gyakran többször kell betanítania és tesztelnie a modellt, hogy pontosabb legyen. Az alábbi útmutató a képosztályozással foglalkozik, az alapelvei azonban hasonlóak az objektumészlelés alapelveihez.
- Mi az a Custom Vision?
- A minta forráskódja a GitHubon található
- SDK-referenciadokumentáció