public async Task CheckFormTypeinSubmodelAndRecognizedForm(bool labeled)
{
var client = CreateFormTrainingClient();
var formClient = client.GetFormRecognizerClient();
var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl);
TrainingOperation trainingOperation = await client.StartTrainingAsync(trainingFilesUri, labeled);
await trainingOperation.WaitForCompletionAsync(PollingInterval);
Assert.IsTrue(trainingOperation.HasValue);
CustomFormModel model = trainingOperation.Value;
Assert.IsNotNull(model.Submodels.FirstOrDefault().FormType);
var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Form1);
RecognizeCustomFormsOperation recognizeOperation = await formClient.StartRecognizeCustomFormsFromUriAsync(model.ModelId, uri);
await recognizeOperation.WaitForCompletionAsync(PollingInterval);
Assert.IsTrue(recognizeOperation.HasValue);
RecognizedForm form = recognizeOperation.Value.Single();
Assert.IsNotNull(form.FormType);
Assert.AreEqual(form.FormType, model.Submodels.FirstOrDefault().FormType);
}
public async Task RecognizeCustomFormsFromFile()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
// Firstly, create a trained model we can use to recognize the custom form.
FormTrainingClient trainingClient = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await trainingClient.StartTraining(new Uri(trainingFileUrl), useTrainingLabels : false).WaitForCompletionAsync();
// Proceed with the custom form recognition.
var credential = new AzureKeyCredential(apiKey);
var client = new FormRecognizerClient(new Uri(endpoint), credential);
string formFilePath = FormRecognizerTestEnvironment.CreatePath("Form_1.jpg");
string modelId = model.ModelId;
#region Snippet:FormRecognizerRecognizeCustomFormsFromFile
using (FileStream stream = new FileStream(formFilePath, FileMode.Open))
{
//@@ string modelId = "<modelId>";
RecognizedFormCollection forms = await client.StartRecognizeCustomForms(modelId, stream).WaitForCompletionAsync();
/*
*
*/
}
#endregion
// Delete the model on completion to clean environment.
trainingClient.DeleteModel(model.ModelId);
}
// </snippet_train_return>
// <snippet_trainlabels>
private static async Task <Guid> TrainModelWithLabelsAsync(
FormRecognizerClient trainingClient, string trainingDataUrl)
{
CustomFormModel model = await trainingClient
.StartTrainingAsync(new Uri(trainingDataUrl), useTrainingLabels : true)
.WaitForCompletionAsync();
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Training model started on: {model.TrainingStartedOn}");
Console.WriteLine($" Training model completed on: {model.TrainingCompletedOn}");
// </snippet_trainlabels>
// <snippet_trainlabels_response>
foreach (CustomFormSubmodel submodel in model.Submodels)
{
Console.WriteLine($"Submodel Form Type: {submodel.FormType}");
foreach (CustomFormModelField field in submodel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Label != null)
{
Console.Write($", FieldLabel: {field.Label}");
}
Console.WriteLine("");
}
}
return(model.ModelId);
}
public async Task OutputModelsTrainedWithoutLabels()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
string formFilePath = FormRecognizerTestEnvironment.CreatePath("Form_1.jpg");
FormRecognizerClient client = new FormRecognizerClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
FormTrainingClient trainingClient = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
// Model trained without labels
CustomFormModel modelTrainedWithoutLabels = await trainingClient.StartTraining(new Uri(trainingFileUrl), useTrainingLabels : false).WaitForCompletionAsync();
using (FileStream stream = new FileStream(formFilePath, FileMode.Open))
{
RecognizedFormCollection forms = await client.StartRecognizeCustomForms(modelTrainedWithoutLabels.ModelId, stream).WaitForCompletionAsync();
// With a form recognized by a model trained without labels, the 'field.Name' property will be denoted
// by a numeric index. To look for the labels identified during the training step,
// use the `field.LabelText` property.
Console.WriteLine("---------Recognizing forms using models trained without labels---------");
foreach (RecognizedForm form in forms)
{
Console.WriteLine($"Form of type: {form.FormType}");
foreach (FormField field in form.Fields.Values)
{
Console.WriteLine($"Field {field.Name}: ");
if (field.LabelData != null)
{
Console.WriteLine($" Label: '{field.LabelData.Text}");
}
Console.WriteLine($" Value: '{field.ValueData.Text}");
Console.WriteLine($" Confidence: '{field.Confidence}");
}
}
// Find the value of unlabeled fields.
foreach (RecognizedForm form in forms)
{
// Find the value of a specific unlabeled field.
Console.WriteLine("Find the value for a specific unlabeled field:");
foreach (FormField field in form.Fields.Values)
{
if (field.LabelData != null && field.LabelData.Text == "Vendor Name:")
{
Console.WriteLine($"The Vendor Name is {field.ValueData.Text}");
}
}
// Find the value of unlabeled fields with specific words
Console.WriteLine("Find the value for labeled field with specific words:");
form.Fields.Values.Where(field => field.LabelData.Text.StartsWith("Ven"))
.ToList().ForEach(v => Console.WriteLine($"{v.LabelData.Text} is {v.ValueData.Text}"));
form.Fields.Values.Where(field => field.LabelData.Text.Contains("Name"))
.ToList().ForEach(v => Console.WriteLine($"{v.LabelData.Text} is {v.ValueData.Text}"));
}
}
}
static async Task Main(string[] args)
{
try
{
// Get configuration settings from AppSettings
IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
IConfigurationRoot configuration = builder.Build();
string formEndpoint = configuration["FormEndpoint"];
string formKey = configuration["FormKey"];
// Authenticate Form Training Client
var credential = new AzureKeyCredential(formKey);
var trainingClient = new FormTrainingClient(new Uri(formEndpoint), credential);
// Get form data for training from storage blob
string trainingStorageUri = configuration["StorageUri"];
// Train model
CustomFormModel model = await trainingClient
.StartTrainingAsync(new Uri(trainingStorageUri), useTrainingLabels : false)
.WaitForCompletionAsync();
// Get model info
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Training model started on: {model.TrainingStartedOn}");
Console.WriteLine($" Training model completed on: {model.TrainingCompletedOn}");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private static async Task <string> TrainModelWithLabelsAsync(
FormTrainingClient trainingClient, string trainingFileUrl)
{
CustomFormModel model = await trainingClient
.StartTrainingAsync(new Uri(trainingFileUrl), useTrainingLabels : true).WaitForCompletionAsync();
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Requested on: {model.TrainingStartedOn}");
Console.WriteLine($" Completed on: {model.TrainingCompletedOn}");
foreach (CustomFormSubmodel submodel in model.Submodels)
{
Console.WriteLine($"Submodel Form Type: {submodel.FormType}");
foreach (CustomFormModelField field in submodel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Accuracy != null)
{
Console.Write($", Accuracy: {field.Accuracy}");
}
Console.WriteLine("");
}
}
return(model.ModelId);
}
public async Task CopyModelWithoutLabelsAndModelName()
{
var sourceClient = CreateFormTrainingClient();
var targetClient = CreateFormTrainingClient();
var resourceId = TestEnvironment.TargetResourceId;
var region = TestEnvironment.TargetResourceRegion;
string modelName = "My model to copy";
await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels : false, modelName : modelName);
CopyAuthorization targetAuth = await targetClient.GetCopyAuthorizationAsync(resourceId, region);
CopyModelOperation operation = await sourceClient.StartCopyModelAsync(trainedModel.ModelId, targetAuth);
await operation.WaitForCompletionAsync(PollingInterval);
Assert.IsTrue(operation.HasValue);
CustomFormModelInfo modelCopied = operation.Value;
Assert.AreEqual(targetAuth.ModelId, modelCopied.ModelId);
Assert.AreNotEqual(trainedModel.ModelId, modelCopied.ModelId);
CustomFormModel modelCopiedFullInfo = await sourceClient.GetCustomModelAsync(modelCopied.ModelId).ConfigureAwait(false);
Assert.AreEqual(modelName, modelCopiedFullInfo.ModelName);
}
public async Task ManageCustomModels()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
#region Snippet:FormRecognizerSampleManageCustomModels
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
// Check number of models in the FormRecognizer account, and the maximum number of models that can be stored.
AccountProperties accountProperties = client.GetAccountProperties();
Console.WriteLine($"Account has {accountProperties.CustomModelCount} models.");
Console.WriteLine($"It can have at most {accountProperties.CustomModelLimit} models.");
// List the first ten or fewer models currently stored in the account.
Pageable <CustomFormModelInfo> models = client.GetCustomModels();
foreach (CustomFormModelInfo modelInfo in models.Take(10))
{
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {modelInfo.ModelId}");
Console.WriteLine($" Model display name: {modelInfo.DisplayName}");
Console.WriteLine($" Is composed model: {modelInfo.Properties.IsComposedModel}");
Console.WriteLine($" Model Status: {modelInfo.Status}");
Console.WriteLine($" Training model started on: {modelInfo.TrainingStartedOn}");
Console.WriteLine($" Training model completed on: {modelInfo.TrainingCompletedOn}");
}
// Create a new model to store in the account
CustomFormModel model = await client.StartTraining(new Uri(trainingFileUrl), useTrainingLabels : false, new TrainingOptions()
{
ModelDisplayName = "My new model"
}).WaitForCompletionAsync();
// Get the model that was just created
CustomFormModel modelCopy = client.GetCustomModel(model.ModelId);
Console.WriteLine($"Custom Model with Id {modelCopy.ModelId} and name {modelCopy.DisplayName} recognizes the following form types:");
foreach (CustomFormSubmodel submodel in modelCopy.Submodels)
{
Console.WriteLine($"Submodel Form Type: {submodel.FormType}");
foreach (CustomFormModelField field in submodel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Label != null)
{
Console.Write($", FieldLabel: {field.Label}");
}
Console.WriteLine("");
}
}
// Delete the model from the account.
client.DeleteModel(model.ModelId);
#endregion
}
public async Task RecognizeCustomFormsFromUri()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
// Firstly, create a trained model we can use to recognize the custom form. Please note that
// models can also be trained using a graphical user interface such as the Form Recognizer
// Labeling Tool found here:
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/quickstarts/label-tool
FormTrainingClient trainingClient = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await trainingClient.StartTrainingAsync(new Uri(trainingFileUrl), useTrainingLabels : false, "My Model").WaitForCompletionAsync();
// Proceed with the custom form recognition.
FormRecognizerClient client = new FormRecognizerClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerSampleRecognizeCustomFormsFromUri
#if SNIPPET
string modelId = "<modelId>";
Uri formUri = < formUri >;
#else
Uri formUri = FormRecognizerTestEnvironment.CreateUri("Form_1.jpg");
string modelId = model.ModelId;
#endif
RecognizeCustomFormsOperation operation = await client.StartRecognizeCustomFormsFromUriAsync(modelId, formUri);
Response <RecognizedFormCollection> operationResponse = await operation.WaitForCompletionAsync();
RecognizedFormCollection forms = operationResponse.Value;
foreach (RecognizedForm form in forms)
{
Console.WriteLine($"Form of type: {form.FormType}");
if (form.FormTypeConfidence.HasValue)
{
Console.WriteLine($"Form type confidence: {form.FormTypeConfidence.Value}");
}
Console.WriteLine($"Form was analyzed with model with ID: {form.ModelId}");
foreach (FormField field in form.Fields.Values)
{
Console.WriteLine($"Field '{field.Name}': ");
if (field.LabelData != null)
{
Console.WriteLine($" Label: '{field.LabelData.Text}'");
}
Console.WriteLine($" Value: '{field.ValueData.Text}'");
Console.WriteLine($" Confidence: '{field.Confidence}'");
}
}
#endregion
// Delete the model on completion to clean environment.
await trainingClient.DeleteModelAsync(model.ModelId);
}
// </snippet_displayanalyze>
// <snippet_displaymodel>
// Display model status
private static void DisplayModelStatus(CustomFormModel model)
{
Console.WriteLine("\nModel :");
Console.WriteLine("\tModel id: " + model.ModelId);
Console.WriteLine("\tStatus: " + model.Status);
Console.WriteLine("\tTraining model started on: " + model.TrainingStartedOn);
Console.WriteLine("\tTraining model completed on: " + model.TrainingCompletedOn);
}
public async Task OutputModelsTrainedWithLabels()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
string formFilePath = FormRecognizerTestEnvironment.CreatePath("Form_1.jpg");
FormRecognizerClient client = new FormRecognizerClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
FormTrainingClient trainingClient = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
// Model trained with labels
CustomFormModel modelTrainedWithLabels = await trainingClient.StartTrainingAsync(new Uri(trainingFileUrl), useTrainingLabels : true, new TrainingOptions()
{
ModelDisplayName = "My Model with labels"
}).WaitForCompletionAsync();
using (FileStream stream = new FileStream(formFilePath, FileMode.Open))
{
RecognizedFormCollection forms = await client.StartRecognizeCustomFormsAsync(modelTrainedWithLabels.ModelId, stream).WaitForCompletionAsync();
// With a form recognized by a model trained with labels, the 'field.Name' key will be the label
// that you gave it at training time.
// Note that Label data is not returned for model trained with labels, as the trained model
// contains this information and therefore the service returns the value of the recognized label.
Console.WriteLine("---------Recognizing forms using models trained with labels---------");
foreach (RecognizedForm form in forms)
{
Console.WriteLine($"Form of type: {form.FormType}");
Console.WriteLine($"Form has form type confidence: {form.FormTypeConfidence.Value}");
Console.WriteLine($"Form was analyzed with model with ID: {form.ModelId}");
foreach (FormField field in form.Fields.Values)
{
Console.WriteLine($"Field {field.Name}: ");
Console.WriteLine($" Value: '{field.ValueData.Text}");
Console.WriteLine($" Confidence: '{field.Confidence}");
}
}
// Find labeled field.
foreach (RecognizedForm form in forms)
{
// Find the specific labeled field.
Console.WriteLine("Find the value for a specific labeled field:");
if (form.Fields.TryGetValue("VendorName", out FormField field))
{
Console.WriteLine($"VendorName is {field.ValueData.Text}");
}
// Find labeled fields with specific words
Console.WriteLine("Find the value for labeled field with specific words:");
form.Fields.Where(kv => kv.Key.StartsWith("Ven"))
.ToList().ForEach(v => Console.WriteLine($"{v.Key} is {v.Value.ValueData.Text}"));
form.Fields.Where(kv => kv.Key.Contains("Name"))
.ToList().ForEach(v => Console.WriteLine($"{v.Key} is {v.Value.ValueData.Text}"));
}
}
}
public override async Task SetupAsync()
{
var trainingClient = new FormTrainingClient(new Uri(Endpoint), new AzureKeyCredential(ApiKey));
var op = await trainingClient.StartTrainingAsync(new Uri(BlobContainerSasUrl), useTrainingLabels : false);
CustomFormModel model = await op.WaitForCompletionAsync();
_modelId = model.ModelId;
}
// </snippet_analyze_response>
// <snippet_manage>
private static async Task ManageModels(
FormRecognizerClient trainingClient, string trainingFileUrl)
{
// </snippet_manage>
// <snippet_manage_model_count>
// Check number of models in the FormRecognizer account,
// and the maximum number of models that can be stored.
AccountProperties accountProperties = trainingClient.GetAccountProperties();
Console.WriteLine($"Account has {accountProperties.CustomModelCount} models.");
Console.WriteLine($"It can have at most {accountProperties.CustomModelLimit}" +
$" models.");
// </snippet_manage_model_count>
// <snippet_manage_model_list>
// List the first ten or fewer models currently stored in the account.
Pageable<CustomFormModelInfo> models = trainingClient.GetModelInfos();
foreach (CustomFormModelInfo modelInfo in models.Take(10))
{
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {modelInfo.ModelId}");
Console.WriteLine($" Model Status: {modelInfo.Status}");
Console.WriteLine($" Created On: {modelInfo.CreatedOn}");
Console.WriteLine($" Last Modified: {modelInfo.LastModified}");
}
// </snippet_manage_model_list>
// <snippet_manage_model_get>
// Create a new model to store in the account
CustomFormModel model = await trainingClient.StartTrainingAsync(
new Uri(trainingFileUrl)).WaitForCompletionAsync();
// Get the model that was just created
CustomFormModel modelCopy = trainingClient.GetCustomModel(model.ModelId);
Console.WriteLine($"Custom Model {modelCopy.ModelId} recognizes the following" +
" form types:");
foreach (CustomFormSubModel subModel in modelCopy.Models)
{
Console.WriteLine($"SubModel Form Type: {subModel.FormType}");
foreach (CustomFormModelField field in subModel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Label != null)
{
Console.Write($", FieldLabel: {field.Label}");
}
Console.WriteLine("");
}
}
// </snippet_manage_model_get>
// <snippet_manage_model_delete>
// Delete the model from the account.
trainingClient.DeleteModel(model.ModelId);
}
public async Task TrainModelWithFormsAndLabels()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
#region Snippet:FormRecognizerSampleTrainModelWithFormsAndLabels
// For this sample, you can use the training forms found in the `trainingFiles` folder.
// Upload the forms to your storage container and then generate a container SAS URL. Note
// that a container URI without SAS is accepted only when the container is public or has a
// managed identity configured.
//
// For instructions to set up forms for training in an Azure Blob Storage Container, please see:
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/build-training-data-set#upload-your-training-data
// For instructions to create a label file for your training forms, please see:
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/label-tool?tabs=v2-1
#if SNIPPET
Uri trainingFileUri = new Uri("<trainingFileUri>");
#else
Uri trainingFileUri = new Uri(TestEnvironment.BlobContainerSasUrlV2);
#endif
string modelName = "My Model with labels";
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
TrainingOperation operation = await client.StartTrainingAsync(trainingFileUri, useTrainingLabels : true, modelName);
Response <CustomFormModel> operationResponse = await operation.WaitForCompletionAsync();
CustomFormModel model = operationResponse.Value;
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model name: {model.ModelName}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Is composed model: {model.Properties.IsComposedModel}");
Console.WriteLine($" Training model started on: {model.TrainingStartedOn}");
Console.WriteLine($" Training model completed on: {model.TrainingCompletedOn}");
foreach (CustomFormSubmodel submodel in model.Submodels)
{
Console.WriteLine($"Submodel Form Type: {submodel.FormType}");
foreach (CustomFormModelField field in submodel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Accuracy != null)
{
Console.Write($", Accuracy: {field.Accuracy}");
}
Console.WriteLine("");
}
}
#endregion
// Delete the model on completion to clean environment.
await client.DeleteModelAsync(model.ModelId);
}
public async Task CopyModel()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
Uri trainingFileUri = new Uri(TestEnvironment.BlobContainerSasUrl);
string resourceId = TestEnvironment.TargetResourceId;
string resourceRegion = TestEnvironment.TargetResourceRegion;
#region Snippet:FormRecognizerSampleCreateCopySourceClient
//@@ string endpoint = "<source_endpoint>";
//@@ string apiKey = "<source_apiKey>";
var sourcecredential = new AzureKeyCredential(apiKey);
var sourceClient = new FormTrainingClient(new Uri(endpoint), sourcecredential);
#endregion
// For the purpose of this sample, we are going to create a trained model to copy. Please note that
// if you already have a model, this is not necessary.
//@@ Uri trainingFileUri = <trainingFileUri>;
TrainingOperation operation = await sourceClient.StartTrainingAsync(trainingFileUri, useTrainingLabels : false);
Response <CustomFormModel> operationResponse = await operation.WaitForCompletionAsync();
CustomFormModel model = operationResponse.Value;
string modelId = model.ModelId;
#region Snippet:FormRecognizerSampleCreateCopyTargetClient
//@@ string endpoint = "<target_endpoint>";
//@@ string apiKey = "<target_apiKey>";
var targetCredential = new AzureKeyCredential(apiKey);
var targetClient = new FormTrainingClient(new Uri(endpoint), targetCredential);
#endregion
#region Snippet:FormRecognizerSampleGetCopyAuthorization
//@@ string resourceId = "<resourceId>";
//@@ string resourceRegion = "<region>";
CopyAuthorization targetAuth = await targetClient.GetCopyAuthorizationAsync(resourceId, resourceRegion);
#endregion
#region Snippet:FormRecognizerSampleToJson
string jsonTargetAuth = targetAuth.ToJson();
#endregion
#region Snippet:FormRecognizerSampleFromJson
CopyAuthorization targetCopyAuth = CopyAuthorization.FromJson(jsonTargetAuth);
#endregion
#region Snippet:FormRecognizerSampleCopyModel
//@@ string modelId = "<source_modelId>";
CustomFormModelInfo newModel = await sourceClient.StartCopyModelAsync(modelId, targetCopyAuth).WaitForCompletionAsync();
Console.WriteLine($"Original model ID => {modelId}");
Console.WriteLine($"Copied model ID => {newModel.ModelId}");
#endregion
}
public async Task StartTraining(bool labeled)
{
var client = CreateInstrumentedClient();
var trainingFiles = new Uri(TestEnvironment.BlobContainerSasUrl);
TrainingOperation operation;
// TODO: sanitize body and enable body recording here.
using (Recording.DisableRequestBodyRecording())
{
operation = await client.StartTrainingAsync(trainingFiles, labeled);
}
await operation.WaitForCompletionAsync();
Assert.IsTrue(operation.HasValue);
CustomFormModel model = operation.Value;
Assert.IsNotNull(model.ModelId);
Assert.IsNotNull(model.CreatedOn);
Assert.IsNotNull(model.LastModified);
Assert.IsNotNull(model.Status);
Assert.AreEqual(CustomFormModelStatus.Ready, model.Status);
Assert.IsNotNull(model.Errors);
Assert.AreEqual(0, model.Errors.Count);
foreach (TrainingDocumentInfo doc in model.TrainingDocuments)
{
Assert.IsNotNull(doc.DocumentName);
Assert.IsNotNull(doc.PageCount);
Assert.AreEqual(TrainingStatus.Succeeded, doc.Status);
Assert.IsNotNull(doc.Errors);
Assert.AreEqual(0, doc.Errors.Count);
}
foreach (var subModel in model.Models)
{
Assert.IsNotNull(subModel.FormType);
foreach (var fields in subModel.Fields)
{
Assert.IsNotNull(fields.Value.Name);
if (labeled)
{
Assert.IsNotNull(fields.Value.Accuracy);
}
else
{
Assert.IsNotNull(fields.Value.Label);
}
}
}
}
private static async Task AnalyzeDynamicCustomForm(FormRecognizerClient recognizerClient, string trainingFileUrl, string formUrl)
{
RecognizeCustomFormsOptions options = new RecognizeCustomFormsOptions();
//train model
FormTrainingClient trainingClient = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await trainingClient.StartTrainingAsync(new Uri(trainingFileUrl), useTrainingLabels : false,
$"VIS-Dynamic-Model-{DateTime.Now.ToShortDateString()}-{DateTime.Now.ToLongTimeString()}").WaitForCompletionAsync();
//string modelId = inModelID;
string modelId = model.ModelId;
//recognize form
RecognizeCustomFormsOperation operation = await recognizerClient.StartRecognizeCustomFormsFromUriAsync(modelId, new Uri(formUrl));
Response <RecognizedFormCollection> operationResponse = await operation.WaitForCompletionAsync();
RecognizedFormCollection forms = operationResponse.Value;
foreach (RecognizedForm form in forms)
{
returnString += $"Form of type: {form.FormType}{Environment.NewLine}";
foreach (FormField field in form.Fields.Values)
{
returnString += $"Field '{field.Name}: ";
if (field.LabelData != null)
{
returnString += $" Label: '{field.LabelData.Text}";
}
returnString += $" Value: '{field.ValueData.Text}";
returnString += $" Confidence: '{field.Confidence}{Environment.NewLine}";
}
returnString += $"Table data:{Environment.NewLine}";
foreach (FormPage page in form.Pages)
{
for (int i = 0; i < page.Tables.Count; i++)
{
FormTable table = page.Tables[i];
//Console.WriteLine($"Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
foreach (FormTableCell cell in table.Cells)
{
returnString += $" Cell ({cell.RowIndex}, {cell.ColumnIndex}) contains {(cell.IsHeader ? "header" : "text")}: '{cell.Text}'{Environment.NewLine}";
}
}
}
}
// Delete the model on completion to clean environment.
await trainingClient.DeleteModelAsync(model.ModelId);
}
public async Task ManageCustomModelsAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
// Check number of models in the FormRecognizer account, and the maximum number of models that can be stored.
AccountProperties accountProperties = await client.GetAccountPropertiesAsync();
Console.WriteLine($"Account has {accountProperties.CustomModelCount} models.");
Console.WriteLine($"It can have at most {accountProperties.CustomModelLimit} models.");
// List the models currently stored in the account.
AsyncPageable <CustomFormModelInfo> models = client.GetModelInfosAsync();
await foreach (CustomFormModelInfo modelInfo in models)
{
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {modelInfo.ModelId}");
Console.WriteLine($" Model Status: {modelInfo.Status}");
Console.WriteLine($" Created On: {modelInfo.CreatedOn}");
Console.WriteLine($" Last Modified: {modelInfo.LastModified}");
}
// Create a new model to store in the account
CustomFormModel model = await client.StartTrainingAsync(new Uri(trainingFileUrl)).WaitForCompletionAsync();
// Get the model that was just created
CustomFormModel modelCopy = await client.GetCustomModelAsync(model.ModelId);
Console.WriteLine($"Custom Model {modelCopy.ModelId} recognizes the following form types:");
foreach (CustomFormSubModel subModel in modelCopy.Models)
{
Console.WriteLine($"SubModel Form Type: {subModel.FormType}");
foreach (CustomFormModelField field in subModel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Label != null)
{
Console.Write($", FieldLabel: {field.Label}");
}
Console.WriteLine("");
}
}
// Delete the model from the account.
await client.DeleteModelAsync(model.ModelId);
}
public async Task StartTraining(bool singlePage, bool labeled)
{
var client = CreateFormTrainingClient();
var trainingFilesUri = new Uri(singlePage ? TestEnvironment.BlobContainerSasUrlV2 : TestEnvironment.MultipageBlobContainerSasUrlV2);
TrainingOperation operation = await client.StartTrainingAsync(trainingFilesUri, labeled);
await operation.WaitForCompletionAsync();
Assert.IsTrue(operation.HasValue);
CustomFormModel model = operation.Value;
Assert.IsNotNull(model.ModelId);
Assert.IsNull(model.ModelName);
Assert.IsNotNull(model.Properties);
Assert.IsFalse(model.Properties.IsComposedModel);
Assert.IsNotNull(model.TrainingStartedOn);
Assert.IsNotNull(model.TrainingCompletedOn);
Assert.AreEqual(CustomFormModelStatus.Ready, model.Status);
Assert.IsNotNull(model.Errors);
Assert.AreEqual(0, model.Errors.Count);
foreach (TrainingDocumentInfo doc in model.TrainingDocuments)
{
Assert.IsNotNull(doc.Name);
Assert.IsNotNull(doc.ModelId);
Assert.IsNotNull(doc.PageCount);
Assert.AreEqual(TrainingStatus.Succeeded, doc.Status);
Assert.IsNotNull(doc.Errors);
Assert.AreEqual(0, doc.Errors.Count);
}
foreach (var submodel in model.Submodels)
{
Assert.IsNotNull(submodel.FormType);
Assert.IsNotNull(submodel.ModelId);
foreach (var fields in submodel.Fields)
{
Assert.IsNotNull(fields.Value.Name);
if (labeled)
{
Assert.IsNotNull(fields.Value.Accuracy);
}
else
{
Assert.IsNotNull(fields.Value.Label);
}
}
}
}
public async Task TrainModelWithForms()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
#region Snippet:FormRecognizerSampleTrainModelWithForms
// For this sample, you can use the training forms found in the `trainingFiles` folder.
// Upload the forms to your storage container and then generate a container SAS URL.
// For instructions on setting up forms for training in an Azure Storage Blob Container, see
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/build-training-data-set#upload-your-training-data
#if SNIPPET
Uri trainingFileUri = < trainingFileUri >;
#else
Uri trainingFileUri = new Uri(TestEnvironment.BlobContainerSasUrlV2);
#endif
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
TrainingOperation operation = await client.StartTrainingAsync(trainingFileUri, useTrainingLabels : false, "My Model");
Response <CustomFormModel> operationResponse = await operation.WaitForCompletionAsync();
CustomFormModel model = operationResponse.Value;
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model name: {model.ModelName}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Is composed model: {model.Properties.IsComposedModel}");
Console.WriteLine($" Training model started on: {model.TrainingStartedOn}");
Console.WriteLine($" Training model completed on: {model.TrainingCompletedOn}");
foreach (CustomFormSubmodel submodel in model.Submodels)
{
Console.WriteLine($"Submodel Form Type: {submodel.FormType}");
foreach (CustomFormModelField field in submodel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Label != null)
{
Console.Write($", FieldLabel: {field.Label}");
}
Console.WriteLine("");
}
}
#endregion
// Delete the model on completion to clean environment.
await client.DeleteModelAsync(model.ModelId);
}
public async Task RecognizeCustomFormsFromFile()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
// Firstly, create a trained model we can use to recognize the custom form. Please note that
// models can also be trained using a graphical user interface such as the Form Recognizer
// Labeling Tool found here:
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/quickstarts/label-tool
FormTrainingClient trainingClient = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await trainingClient.StartTrainingAsync(new Uri(trainingFileUrl), useTrainingLabels : false, new TrainingOptions()
{
ModelName = "My Model"
}).WaitForCompletionAsync();
// Proceed with the custom form recognition.
FormRecognizerClient client = new FormRecognizerClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
string formFilePath = FormRecognizerTestEnvironment.CreatePath("Form_1.jpg");
string modelId = model.ModelId;
using (FileStream stream = new FileStream(formFilePath, FileMode.Open))
{
RecognizedFormCollection forms = await client.StartRecognizeCustomFormsAsync(modelId, stream).WaitForCompletionAsync();
foreach (RecognizedForm form in forms)
{
Console.WriteLine($"Form of type: {form.FormType}");
Console.WriteLine($"Form was analyzed with model with ID: {form.ModelId}");
foreach (FormField field in form.Fields.Values)
{
Console.WriteLine($"Field '{field.Name}: ");
if (field.LabelData != null)
{
Console.WriteLine($" Label: '{field.LabelData.Text}");
}
Console.WriteLine($" Value: '{field.ValueData.Text}");
Console.WriteLine($" Confidence: '{field.Confidence}");
}
}
}
// Delete the model on completion to clean environment.
await trainingClient.DeleteModelAsync(model.ModelId);
}
public async Task FormTrainingClientCanAuthenticateWithTokenCredential()
{
var client = CreateFormTrainingClient(useTokenCredential: true);
var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl);
TrainingOperation operation = await client.StartTrainingAsync(trainingFilesUri, useTrainingLabels : false);
CustomFormModel model = await operation.WaitForCompletionAsync(PollingInterval);
// Sanity check to make sure we got an actual response back from the service.
Assert.IsNotNull(model.ModelId);
Assert.AreEqual(CustomFormModelStatus.Ready, model.Status);
Assert.IsNotNull(model.Errors);
Assert.AreEqual(0, model.Errors.Count);
}
public async Task TrainModelWithFormsAndLabels()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
#region Snippet:FormRecognizerSampleTrainModelWithFormsAndLabels
// For this sample, you can use the training forms found in the `trainingFiles` folder.
// Upload the forms to your storage container and then generate a container SAS URL.
// For instructions to set up forms for training in an Azure Storage Blob Container, please see:
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/build-training-data-set#upload-your-training-data
// For instructions to create a label file for your training forms, please see:
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/quickstarts/label-tool
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await client.StartTrainingAsync(new Uri(trainingFileUrl), useTrainingLabels : true, new TrainingOptions()
{
ModelName = "My Model with labels"
}).WaitForCompletionAsync();
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model name: {model.ModelName}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Is composed model: {model.Properties.IsComposedModel}");
Console.WriteLine($" Training model started on: {model.TrainingStartedOn}");
Console.WriteLine($" Training model completed on: {model.TrainingCompletedOn}");
foreach (CustomFormSubmodel submodel in model.Submodels)
{
Console.WriteLine($"Submodel Form Type: {submodel.FormType}");
foreach (CustomFormModelField field in submodel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Accuracy != null)
{
Console.Write($", Accuracy: {field.Accuracy}");
}
Console.WriteLine("");
}
}
#endregion
// Delete the model on completion to clean environment.
await client.DeleteModelAsync(model.ModelId);
}
public async Task RecognizeCustomFormsFromUri()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
// Firstly, create a trained model we can use to recognize the custom form. Please note that
// models can also be trained using a graphical user interface such as the Form Recognizer
// Labeling Tool found here:
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/quickstarts/label-tool
FormTrainingClient trainingClient = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await trainingClient.StartTraining(new Uri(trainingFileUrl)).WaitForCompletionAsync();
// Proceed with the custom form recognition.
FormRecognizerClient client = new FormRecognizerClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
string formUri = FormRecognizerTestEnvironment.CreateUri("Form_1.jpg");
string modelId = model.ModelId;
#region Snippet:FormRecognizerSample3RecognizeCustomFormsFromUri
//@@ string modelId = "<modelId>";
RecognizedFormCollection forms = await client.StartRecognizeCustomFormsFromUri(modelId, new Uri(formUri)).WaitForCompletionAsync();
foreach (RecognizedForm form in forms)
{
Console.WriteLine($"Form of type: {form.FormType}");
foreach (FormField field in form.Fields.Values)
{
Console.WriteLine($"Field '{field.Name}: ");
if (field.LabelText != null)
{
Console.WriteLine($" Label: '{field.LabelText.Text}");
}
Console.WriteLine($" Value: '{field.ValueText.Text}");
Console.WriteLine($" Confidence: '{field.Confidence}");
}
}
#endregion
// Delete the model on completion to clean environment.
trainingClient.DeleteModel(model.ModelId);
}
public async Task StartTraining(bool labeled)
{
var client = CreateInstrumentedClient();
TrainingOperation operation = await client.StartTrainingAsync(_containerUri, labeled);
await operation.WaitForCompletionAsync();
Assert.IsTrue(operation.HasValue);
CustomFormModel model = operation.Value;
Assert.IsNotNull(model.ModelId);
Assert.IsNotNull(model.CreatedOn);
Assert.IsNotNull(model.LastModified);
Assert.IsNotNull(model.Status);
Assert.AreEqual(CustomFormModelStatus.Ready, model.Status);
Assert.IsNotNull(model.Errors);
Assert.AreEqual(0, model.Errors.Count);
foreach (TrainingDocumentInfo doc in model.TrainingDocuments)
{
Assert.IsNotNull(doc.DocumentName);
Assert.IsNotNull(doc.PageCount);
Assert.AreEqual(TrainingStatus.Succeeded, doc.Status);
Assert.IsNotNull(doc.Errors);
Assert.AreEqual(0, doc.Errors.Count);
}
foreach (var subModel in model.Models)
{
Assert.IsNotNull(subModel.FormType);
foreach (var fields in subModel.Fields)
{
Assert.IsNotNull(fields.Value.Name);
if (labeled)
{
Assert.IsNotNull(fields.Value.Accuracy);
}
else
{
Assert.IsNotNull(fields.Value.Label);
}
}
}
}
public async Task CopyComposedModel(bool useTokenCredential)
{
var sourceClient = CreateFormTrainingClient(useTokenCredential);
var targetClient = CreateFormTrainingClient(useTokenCredential);
var resourceId = TestEnvironment.TargetResourceId;
var region = TestEnvironment.TargetResourceRegion;
await using var trainedModelA = await CreateDisposableTrainedModelAsync(useTrainingLabels : true);
await using var trainedModelB = await CreateDisposableTrainedModelAsync(useTrainingLabels : true);
var modelIds = new List <string> {
trainedModelA.ModelId, trainedModelB.ModelId
};
string modelName = "My composed model";
CreateComposedModelOperation operation = await sourceClient.StartCreateComposedModelAsync(modelIds, modelName);
await operation.WaitForCompletionAsync(PollingInterval);
Assert.IsTrue(operation.HasValue);
CustomFormModel composedModel = operation.Value;
CopyAuthorization targetAuth = await targetClient.GetCopyAuthorizationAsync(resourceId, region);
CopyModelOperation copyOperation = await sourceClient.StartCopyModelAsync(composedModel.ModelId, targetAuth);
await copyOperation.WaitForCompletionAsync(PollingInterval);
Assert.IsTrue(copyOperation.HasValue);
CustomFormModelInfo modelCopied = copyOperation.Value;
Assert.AreEqual(targetAuth.ModelId, modelCopied.ModelId);
Assert.AreNotEqual(composedModel.ModelId, modelCopied.ModelId);
CustomFormModel modelCopiedFullInfo = await sourceClient.GetCustomModelAsync(modelCopied.ModelId).ConfigureAwait(false);
Assert.AreEqual(modelName, modelCopiedFullInfo.ModelName);
foreach (var submodel in modelCopiedFullInfo.Submodels)
{
Assert.IsTrue(modelIds.Contains(submodel.ModelId));
}
}
public async Task FormTrainingClientCanAuthenticateWithTokenCredential()
{
var client = CreateInstrumentedFormTrainingClient(useTokenCredential: true);
var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl);
TrainingOperation operation;
// TODO: sanitize body and enable body recording here.
using (Recording.DisableRequestBodyRecording())
{
operation = await client.StartTrainingAsync(trainingFilesUri, useTrainingLabels : false);
}
// Sanity check to make sure we got an actual response back from the service.
CustomFormModel model = await operation.WaitForCompletionAsync();
Assert.IsNotNull(model.ModelId);
Assert.AreEqual(CustomFormModelStatus.Ready, model.Status);
Assert.IsNotNull(model.Errors);
Assert.AreEqual(0, model.Errors.Count);
}
public async Task TrainModelWithFormsAndLabels()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
#region Snippet:FormRecognizerSample5TrainModelWithFormsAndLabels
// For instructions to set up forms for training in an Azure Storage Blob Container, please see:
// https://docs.microsoft.com/en-us/azure/cognitive-services/form-recognizer/quickstarts/curl-train-extract#train-a-form-recognizer-model
// For instructions to create a label file for your training forms, please see:
// https://docs.microsoft.com/en-us/azure/cognitive-services/form-recognizer/quickstarts/label-tool
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await client.StartTrainingAsync(new Uri(trainingFileUrl), useTrainingLabels : true).WaitForCompletionAsync();
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Requested on: {model.RequestedOn}");
Console.WriteLine($" Completed on: {model.CompletedOn}");
foreach (CustomFormSubModel subModel in model.Models)
{
Console.WriteLine($"SubModel Form Type: {subModel.FormType}");
foreach (CustomFormModelField field in subModel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Accuracy != null)
{
Console.Write($", Accuracy: {field.Accuracy}");
}
Console.WriteLine("");
}
}
#endregion
// Delete the model on completion to clean environment.
client.DeleteModel(model.ModelId);
}
// </snippet_maintask>
// <snippet_train>
// Train model using training form data (pdf, jpg, png files)
private static async Task <string> TrainModelAsync(
FormTrainingClient formTrainingClient, string trainingDataUrl)
{
if (!Uri.IsWellFormedUriString(trainingDataUrl, UriKind.Absolute))
{
Console.WriteLine("\nInvalid trainingDataUrl:\n{0} \n", trainingDataUrl);
return(null);
}
try
{
CustomFormModel result = await formTrainingClient.StartTrainingAsync(new Uri(trainingDataUrl), useTrainingLabels : false).WaitForCompletionAsync();
DisplayModelStatus(result);
return(result.ModelId);
}
catch (RequestFailedException e)
{
Console.WriteLine("Train Model : " + e.Message);
return(null);
}
}
public async Task TrainModelWithForms()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
string trainingFileUrl = TestEnvironment.BlobContainerSasUrl;
#region Snippet:FormRecognizerSample4TrainModelWithForms
// For instructions on setting up forms for training in an Azure Storage Blob Container, see
// https://docs.microsoft.com/azure/cognitive-services/form-recognizer/quickstarts/curl-train-extract#train-a-form-recognizer-model
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
CustomFormModel model = await client.StartTrainingAsync(new Uri(trainingFileUrl)).WaitForCompletionAsync();
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {model.ModelId}");
Console.WriteLine($" Model Status: {model.Status}");
Console.WriteLine($" Created On: {model.CreatedOn}");
Console.WriteLine($" Last Modified: {model.LastModified}");
foreach (CustomFormSubModel subModel in model.Models)
{
Console.WriteLine($"SubModel Form Type: {subModel.FormType}");
foreach (CustomFormModelField field in subModel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Label != null)
{
Console.Write($", FieldLabel: {field.Label}");
}
Console.WriteLine("");
}
}
#endregion
// Delete the model on completion to clean environment.
client.DeleteModel(model.ModelId);
}
