async def test_list_model_auth_bad_key(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormTrainingClient(form_recognizer_account,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
result = client.list_custom_models()
async for res in result:
test = res
async def test_list_model_auth_bad_key(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormTrainingClient(formrecognizer_test_endpoint,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
async with client:
result = client.list_custom_models()
async for res in result:
test = res
async def test_get_form_recognizer_client(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
transport = AioHttpTransport()
ftc = FormTrainingClient(endpoint=form_recognizer_account, credential=AzureKeyCredential(form_recognizer_account_key), transport=transport)
async with ftc:
await ftc.get_account_properties()
assert transport.session is not None
async with ftc.get_form_recognizer_client() as frc:
assert transport.session is not None
await frc.recognize_receipts_from_url(self.receipt_url_jpg)
await ftc.get_account_properties()
assert transport.session is not None
async def main():
sample = DifferentiateOutputModelsTrainedWithAndWithoutLabelsSampleAsync()
labeled_model_id = None
unlabeled_model_id = None
if os.getenv("CONTAINER_SAS_URL_WITH_LABELS_V2") or os.getenv(
"CONTAINER_SAS_URL_WITHOUT_LABELS_V2"):
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
endpoint = os.getenv("AZURE_FORM_RECOGNIZER_ENDPOINT")
key = os.getenv("AZURE_FORM_RECOGNIZER_KEY")
labeled = os.getenv("CONTAINER_SAS_URL_WITH_LABELS_V2")
unlabeled = os.getenv("CONTAINER_SAS_URL_WITHOUT_LABELS_V2")
if not endpoint or not key:
raise ValueError(
"Please provide endpoint and API key to run the samples.")
form_training_client = FormTrainingClient(
endpoint=endpoint, credential=AzureKeyCredential(key))
async with form_training_client:
if labeled:
model = await (await form_training_client.begin_training(
labeled, use_training_labels=True)).result()
labeled_model_id = model.model_id
if unlabeled:
model = await (await form_training_client.begin_training(
unlabeled, use_training_labels=False)).result()
unlabeled_model_id = model.model_id
await sample.recognize_custom_forms(labeled_model_id, unlabeled_model_id)
async def train_model_with_labels(self):
from azure.ai.formrecognizer.aio import FormTrainingClient
from azure.core.credentials import AzureKeyCredential
form_training_client = FormTrainingClient(
endpoint=self.endpoint, credential=AzureKeyCredential(self.key))
async with form_training_client:
model = await form_training_client.train_model(
self.container_sas_url, use_training_labels=True)
# Custom model information
print("Model ID: {}".format(model.model_id))
print("Status: {}".format(model.status))
print("Requested on: {}".format(model.requested_on))
print("Completed on: {}".format(model.completed_on))
print("Recognized fields:")
# looping through the submodels, which contains the fields they were trained on
# The labels are based on the ones you gave the training document.
for submodel in model.models:
print("...The submodel with form type {} has accuracy '{}'".
format(submodel.form_type, submodel.accuracy))
for name, field in submodel.fields.items():
print(
"...The model found field '{}' to have name '{}' with an accuracy of {}"
.format(name, field.name, field.accuracy))
# Training result information
for doc in model.training_documents:
print("Document name: {}".format(doc.document_name))
print("Document status: {}".format(doc.status))
print("Document page count: {}".format(doc.page_count))
print("Document errors: {}".format(doc.errors))
async def test_sample_copy_model_async(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
os.environ['CONTAINER_SAS_URL'] = self.get_settings_value(
"FORM_RECOGNIZER_STORAGE_CONTAINER_SAS_URL")
ftc = FormTrainingClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
container_sas_url = os.environ['CONTAINER_SAS_URL']
async with ftc:
poller = await ftc.begin_training(container_sas_url,
use_training_labels=False)
model = await poller.result()
os.environ['AZURE_SOURCE_MODEL_ID'] = model.model_id
os.environ[
"AZURE_FORM_RECOGNIZER_TARGET_ENDPOINT"] = form_recognizer_account
os.environ[
"AZURE_FORM_RECOGNIZER_TARGET_KEY"] = form_recognizer_account_key
os.environ["AZURE_FORM_RECOGNIZER_TARGET_REGION"] = location
os.environ["AZURE_FORM_RECOGNIZER_TARGET_RESOURCE_ID"] = \
"/subscriptions/" + self.get_settings_value("SUBSCRIPTION_ID") + "/resourceGroups/" + \
resource_group.name + "/providers/Microsoft.CognitiveServices/accounts/" + \
FormRecognizerTest._FORM_RECOGNIZER_NAME
_test_file('sample_copy_model_async.py', form_recognizer_account,
form_recognizer_account_key)
async def manage_custom_models(self):
# [START get_account_properties_async]
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import ResourceNotFoundError
from azure.ai.formrecognizer.aio import FormTrainingClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
async with FormTrainingClient(
endpoint=endpoint,
credential=AzureKeyCredential(key)) as form_training_client:
# First, we see how many custom models we have, and what our limit is
account_properties = await form_training_client.get_account_properties(
)
print(
"Our account has {} custom models, and we can have at most {} custom models\n"
.format(account_properties.custom_model_count,
account_properties.custom_model_limit))
# [END get_account_properties_async]
# Next, we get a paged list of all of our custom models
# [START list_custom_models_async]
custom_models = form_training_client.list_custom_models()
print("We have models with the following IDs:")
# Let's pull out the first model
first_model = await custom_models.__anext__()
print(first_model.model_id)
async for model in custom_models:
print(model.model_id)
# [END list_custom_models_async]
# Now we'll get information for the first custom model in the paged list
# [START get_custom_model_async]
custom_model = await form_training_client.get_custom_model(
model_id=first_model.model_id)
print("\nModel ID: {}".format(custom_model.model_id))
print("Status: {}".format(custom_model.status))
print("Model name: {}".format(custom_model.model_name))
print("Is this a composed model?: {}".format(
custom_model.properties.is_composed_model))
print("Training started on: {}".format(
custom_model.training_started_on))
print("Training completed on: {}".format(
custom_model.training_completed_on))
# [END get_custom_model_async]
# Finally, we will delete this model by ID
# [START delete_model_async]
await form_training_client.delete_model(
model_id=custom_model.model_id)
try:
await form_training_client.get_custom_model(
model_id=custom_model.model_id)
except ResourceNotFoundError:
print("Successfully deleted model with id {}".format(
custom_model.model_id))
async def main():
sample = CopyModelSampleAsync()
model_id = None
if os.getenv("CONTAINER_SAS_URL"):
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
endpoint = os.getenv("AZURE_FORM_RECOGNIZER_ENDPOINT")
key = os.getenv("AZURE_FORM_RECOGNIZER_KEY")
if not endpoint or not key:
raise ValueError(
"Please provide endpoint and API key to run the samples.")
form_training_client = FormTrainingClient(
endpoint=endpoint, credential=AzureKeyCredential(key))
async with form_training_client:
model = await (await
form_training_client.begin_training(
os.getenv("CONTAINER_SAS_URL"),
use_training_labels=True)).result()
model_id = model.model_id
await sample.copy_model_async(model_id)
async def main():
sample = TestDifferentiateOutputLabeledTablesAsync()
fixed_model_id = None
dynamic_model_id = None
if os.getenv("CONTAINER_SAS_URL_FIXED_V2") or os.getenv(
"CONTAINER_SAS_URL_DYNAMIC_V2"):
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
endpoint = os.getenv("AZURE_FORM_RECOGNIZER_ENDPOINT")
key = os.getenv("AZURE_FORM_RECOGNIZER_KEY")
fixed = os.getenv("CONTAINER_SAS_URL_FIXED_V2")
dynamic = os.getenv("CONTAINER_SAS_URL_DYNAMIC_V2")
if not endpoint or not key:
raise ValueError(
"Please provide endpoint and API key to run the samples.")
form_training_client = FormTrainingClient(
endpoint=endpoint, credential=AzureKeyCredential(key))
async with form_training_client:
if fixed:
model = await (await form_training_client.begin_training(
fixed, use_training_labels=True)).result()
fixed_model_id = model.model_id
if dynamic:
model = await (await form_training_client.begin_training(
dynamic, use_training_labels=True)).result()
dynamic_model_id = model.model_id
await sample.test_recognize_tables_fixed_rows_async(fixed_model_id)
await sample.test_recognize_tables_dynamic_rows_async(dynamic_model_id)
async def test_training_auth_bad_key(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormTrainingClient(form_recognizer_account,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
result = await client.train_model("xx")
async def train_model_without_labels(self):
# [START training_async]
from azure.ai.formrecognizer.aio import FormTrainingClient
from azure.core.credentials import AzureKeyCredential
async with FormTrainingClient(self.endpoint,
AzureKeyCredential(
self.key)) as form_training_client:
# Default for train_model is `use_labels=False`
model = await form_training_client.train_model(
self.container_sas_url)
# Custom model information
print("Model ID: {}".format(model.model_id))
print("Status: {}".format(model.status))
print("Created on: {}".format(model.created_on))
print("Last modified: {}".format(model.last_modified))
print("Recognized fields:")
# Looping through the submodels, which contains the fields they were trained on
for submodel in model.models:
print("...The submodel has form type '{}'".format(
submodel.form_type))
for name, field in submodel.fields.items():
print("...The model found field '{}' to have label '{}'".
format(name, field.label))
# [END training_async]
# Training result information
for doc in model.training_documents:
print("Document name: {}".format(doc.document_name))
print("Document status: {}".format(doc.status))
print("Document page count: {}".format(doc.page_count))
print("Document errors: {}".format(doc.errors))
async def test_active_directory_auth_async(self):
token = self.generate_oauth_token()
endpoint = self.get_oauth_endpoint()
client = FormTrainingClient(endpoint, token)
async with client:
props = await client.get_account_properties()
self.assertIsNotNone(props)
async def test_account_properties_auth_bad_key(
self, formrecognizer_test_endpoint, formrecognizer_test_api_key):
client = FormTrainingClient(formrecognizer_test_endpoint,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
async with client:
result = await client.get_account_properties()
async def test_delete_model_empty_model_id(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormTrainingClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with self.assertRaises(ValueError):
result = await client.delete_model("")
async def test_sample_recognize_custom_forms_async(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
os.environ['CONTAINER_SAS_URL'] = self.get_settings_value("FORM_RECOGNIZER_STORAGE_CONTAINER_SAS_URL")
ftc = FormTrainingClient(form_recognizer_account, AzureKeyCredential(form_recognizer_account_key))
container_sas_url = os.environ['CONTAINER_SAS_URL']
poller = await ftc.begin_training(container_sas_url, use_training_labels=False)
model = await poller.result()
os.environ['CUSTOM_TRAINED_MODEL_ID'] = model.model_id
_test_file('sample_recognize_custom_forms_async.py', form_recognizer_account, form_recognizer_account_key)
def test_document_api_version_form_training_client(self):
with pytest.raises(ValueError) as excinfo:
client = FormTrainingClient(
"url",
"key",
api_version=DocumentAnalysisApiVersion.V2021_09_30_PREVIEW)
assert "Unsupported API version '2021-09-30-preview'. Please select from: {}\nAPI version '2021-09-30-preview' is " \
"only available for DocumentAnalysisClient and DocumentModelAdministrationClient.".format(
", ".join(v.value for v in FormRecognizerApiVersion)) == str(excinfo.value)
async def test_training_auth_bad_key(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormTrainingClient(formrecognizer_test_endpoint,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
async with client:
poller = await client.begin_training("xx",
use_training_labels=False)
result = await poller.result()
async def test_training_auth_bad_key(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormTrainingClient(form_recognizer_account,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
poller = await client.begin_training("xx",
use_training_labels=False)
result = await poller.result()
async def test_account_properties(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormTrainingClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
properties = await client.get_account_properties()
self.assertIsNotNone(properties.custom_model_limit)
self.assertIsNotNone(properties.custom_model_count)
async def authentication_with_api_key_credential_form_training_client_async(self):
# [START create_ft_client_with_key_async]
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
form_training_client = FormTrainingClient(endpoint, AzureKeyCredential(key))
# [END create_ft_client_with_key_async]
async with form_training_client:
properties = await form_training_client.get_account_properties()
async def manage_custom_models(self):
# [START get_account_properties_async]
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import ResourceNotFoundError
from azure.ai.formrecognizer.aio import FormTrainingClient
async with FormTrainingClient(endpoint=self.endpoint,
credential=AzureKeyCredential(
self.key)) as form_training_client:
# First, we see how many custom models we have, and what our limit is
account_properties = await form_training_client.get_account_properties(
)
print(
"Our account has {} custom models, and we can have at most {} custom models"
.format(account_properties.custom_model_count,
account_properties.custom_model_limit))
# [END get_account_properties_async]
# Next, we get a paged list of all of our custom models
# [START list_model_infos_async]
custom_models = form_training_client.list_model_infos()
print("We have models with the following ids:")
# Let's pull out the first model
first_model = None
async for model in custom_models:
print(model.model_id)
if not first_model:
first_model = model
# [END list_model_infos_async]
# Now we'll get the first custom model in the paged list
# [START get_custom_model_async]
custom_model = await form_training_client.get_custom_model(
model_id=first_model.model_id)
print("Model ID: {}".format(custom_model.model_id))
print("Status: {}".format(custom_model.status))
print("Created on: {}".format(custom_model.created_on))
print("Last modified: {}".format(custom_model.last_modified))
# [END get_custom_model_async]
# Finally, we will delete this model by ID
# [START delete_model_async]
await form_training_client.delete_model(
model_id=custom_model.model_id)
try:
await form_training_client.get_custom_model(
model_id=custom_model.model_id)
except ResourceNotFoundError:
print("Successfully deleted model with id {}".format(
custom_model.model_id))
async def copy_model_async(self):
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
source_endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
source_key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
target_endpoint = os.environ["AZURE_FORM_RECOGNIZER_TARGET_ENDPOINT"]
target_key = os.environ["AZURE_FORM_RECOGNIZER_TARGET_KEY"]
source_model_id = os.environ["AZURE_SOURCE_MODEL_ID"]
target_region = os.environ["AZURE_FORM_RECOGNIZER_TARGET_REGION"]
target_resource_id = os.environ[
"AZURE_FORM_RECOGNIZER_TARGET_RESOURCE_ID"]
# [START get_copy_authorization_async]
target_client = FormTrainingClient(
endpoint=target_endpoint,
credential=AzureKeyCredential(target_key))
async with target_client:
target = await target_client.get_copy_authorization(
resource_region=target_region, resource_id=target_resource_id)
# [END get_copy_authorization_async]
# [START copy_model_async]
source_client = FormTrainingClient(
endpoint=source_endpoint,
credential=AzureKeyCredential(source_key))
target_client = FormTrainingClient(
endpoint=target_endpoint,
credential=AzureKeyCredential(target_key))
async with source_client:
copy = await source_client.copy_model(model_id=source_model_id,
target=target)
async with target_client:
copied_over_model = await target_client.get_custom_model(
copy.model_id)
print("Model ID: {}".format(copied_over_model.model_id))
print("Status: {}".format(copied_over_model.status))
async def copy_model_async(self, custom_model_id):
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
source_endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
source_key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
target_endpoint = os.environ["AZURE_FORM_RECOGNIZER_TARGET_ENDPOINT"]
target_key = os.environ["AZURE_FORM_RECOGNIZER_TARGET_KEY"]
source_model_id = os.getenv("AZURE_SOURCE_MODEL_ID", custom_model_id)
target_region = os.environ["AZURE_FORM_RECOGNIZER_TARGET_REGION"]
target_resource_id = os.environ[
"AZURE_FORM_RECOGNIZER_TARGET_RESOURCE_ID"]
# [START get_copy_authorization_async]
target_client = FormTrainingClient(
endpoint=target_endpoint,
credential=AzureKeyCredential(target_key))
async with target_client:
target = await target_client.get_copy_authorization(
resource_region=target_region, resource_id=target_resource_id)
# model ID that target client will use to access the model once copy is complete
print("Model ID: {}".format(target["modelId"]))
# [END get_copy_authorization_async]
# [START copy_model_async]
source_client = FormTrainingClient(
endpoint=source_endpoint,
credential=AzureKeyCredential(source_key))
async with source_client:
poller = await source_client.begin_copy_model(
model_id=source_model_id,
target=
target # output from target client's call to get_copy_authorization()
)
copied_over_model = await poller.result()
print("Model ID: {}".format(copied_over_model.model_id))
print("Status: {}".format(copied_over_model.status))
async def authentication_with_azure_active_directory_form_training_client_async(
self):
"""DefaultAzureCredential will use the values from these environment
variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
"""
# [START create_ft_client_with_aad_async]
from azure.ai.formrecognizer.aio import FormTrainingClient
from azure.identity.aio import DefaultAzureCredential
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
credential = DefaultAzureCredential()
form_training_client = FormTrainingClient(endpoint, credential)
# [END create_ft_client_with_aad_async]
properties = await form_training_client.get_account_properties()
async def train_model_with_labels(self):
from azure.ai.formrecognizer.aio import FormTrainingClient
from azure.core.credentials import AzureKeyCredential
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
container_sas_url = os.environ["CONTAINER_SAS_URL"]
form_training_client = FormTrainingClient(
endpoint=endpoint, credential=AzureKeyCredential(key))
async with form_training_client:
poller = await form_training_client.begin_training(
container_sas_url,
use_training_labels=True,
model_name="mymodel")
model = await poller.result()
# Custom model information
print("Model ID: {}".format(model.model_id))
print("Status: {}".format(model.status))
print("Model name: {}".format(model.model_name))
print("Is this a composed model?: {}".format(
model.properties.is_composed_model))
print("Training started on: {}".format(model.training_started_on))
print("Training completed on: {}".format(
model.training_completed_on))
print("Recognized fields:")
# looping through the submodels, which contains the fields they were trained on
# The labels are based on the ones you gave the training document.
for submodel in model.submodels:
print("...The submodel has model ID: {}".format(
submodel.model_id))
print(
"...The submodel with form type {} has an average accuracy '{}'"
.format(submodel.form_type, submodel.accuracy))
for name, field in submodel.fields.items():
print(
"...The model found the field '{}' with an accuracy of {}"
.format(name, field.accuracy))
# Training result information
for doc in model.training_documents:
print("Document name: {}".format(doc.name))
print("Document status: {}".format(doc.status))
print("Document page count: {}".format(doc.page_count))
print("Document errors: {}".format(doc.errors))
async def test_sample_differentiate_output_models_trained_with_and_without_labels_async(
self, resource_group, location, form_recognizer_account, form_recognizer_account_key
):
os.environ['CONTAINER_SAS_URL'] = self.get_settings_value("FORM_RECOGNIZER_STORAGE_CONTAINER_SAS_URL")
ftc = FormTrainingClient(form_recognizer_account, AzureKeyCredential(form_recognizer_account_key))
container_sas_url = os.environ['CONTAINER_SAS_URL']
async with ftc:
poller = await ftc.begin_training(container_sas_url, use_training_labels=False)
unlabeled_model = await poller.result()
poller = await ftc.begin_training(container_sas_url, use_training_labels=True)
labeled_model = await poller.result()
os.environ["ID_OF_MODEL_TRAINED_WITH_LABELS"] = labeled_model.model_id
os.environ["ID_OF_MODEL_TRAINED_WITHOUT_LABELS"] = unlabeled_model.model_id
_test_file('sample_differentiate_output_models_trained_with_and_without_labels_async.py',
form_recognizer_account,
form_recognizer_account_key
)
async def test_logging_info_ft_client(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormTrainingClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
mock_handler = MockHandler()
logger = logging.getLogger("azure")
logger.addHandler(mock_handler)
logger.setLevel(logging.INFO)
async with client:
result = await client.get_account_properties()
for message in mock_handler.messages:
if message.levelname == "INFO":
# not able to use json.loads here. At INFO level only API key should be REDACTED
if message.message.find("Ocp-Apim-Subscription-Key") != -1:
assert message.message.find("REDACTED") != -1
else:
assert message.message.find("REDACTED") == -1
async def train_model_without_labels(self):
# [START training_async]
from azure.ai.formrecognizer.aio import FormTrainingClient
from azure.core.credentials import AzureKeyCredential
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
container_sas_url = os.environ["CONTAINER_SAS_URL"]
async with FormTrainingClient(
endpoint, AzureKeyCredential(key)) as form_training_client:
poller = await form_training_client.begin_training(
container_sas_url, use_training_labels=False)
model = await poller.result()
# Custom model information
print("Model ID: {}".format(model.model_id))
print("Status: {}".format(model.status))
print("Model name: {}".format(model.model_name))
print("Training started on: {}".format(model.training_started_on))
print("Training completed on: {}".format(
model.training_completed_on))
print("Recognized fields:")
# Looping through the submodels, which contains the fields they were trained on
for submodel in model.submodels:
print("...The submodel has form type '{}'".format(
submodel.form_type))
for name, field in submodel.fields.items():
print("...The model found field '{}' to have label '{}'".
format(name, field.label))
# [END training_async]
# Training result information
for doc in model.training_documents:
print("Document name: {}".format(doc.name))
print("Document status: {}".format(doc.status))
print("Document page count: {}".format(doc.page_count))
print("Document errors: {}".format(doc.errors))
def test_bad_api_version_form_training_client(self):
with pytest.raises(ValueError) as excinfo:
client = FormTrainingClient("url", "key", api_version="9")
assert "Unsupported API version '9'. Please select from: {}".format(
", ".join(v.value
for v in FormRecognizerApiVersion)) == str(excinfo.value)
async def create_composed_model_async(self):
# [START begin_create_composed_model_async]
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
po_supplies = os.environ['PURCHASE_ORDER_OFFICE_SUPPLIES_SAS_URL_V2']
po_equipment = os.environ['PURCHASE_ORDER_OFFICE_EQUIPMENT_SAS_URL_V2']
po_furniture = os.environ['PURCHASE_ORDER_OFFICE_FURNITURE_SAS_URL_V2']
po_cleaning_supplies = os.environ[
'PURCHASE_ORDER_OFFICE_CLEANING_SUPPLIES_SAS_URL_V2']
form_training_client = FormTrainingClient(
endpoint=endpoint, credential=AzureKeyCredential(key))
async with form_training_client:
supplies_poller = await form_training_client.begin_training(
po_supplies,
use_training_labels=True,
model_name="Purchase order - Office supplies")
equipment_poller = await form_training_client.begin_training(
po_equipment,
use_training_labels=True,
model_name="Purchase order - Office Equipment")
furniture_poller = await form_training_client.begin_training(
po_furniture,
use_training_labels=True,
model_name="Purchase order - Furniture")
cleaning_supplies_poller = await form_training_client.begin_training(
po_cleaning_supplies,
use_training_labels=True,
model_name="Purchase order - Cleaning Supplies")
supplies_model = await supplies_poller.result()
equipment_model = await equipment_poller.result()
furniture_model = await furniture_poller.result()
cleaning_supplies_model = await cleaning_supplies_poller.result()
models_trained_with_labels = [
supplies_model.model_id, equipment_model.model_id,
furniture_model.model_id, cleaning_supplies_model.model_id
]
poller = await form_training_client.begin_create_composed_model(
models_trained_with_labels,
model_name="Office Supplies Composed Model")
model = await poller.result()
print("Office Supplies Composed Model Info:")
print("Model ID: {}".format(model.model_id))
print("Model name: {}".format(model.model_name))
print("Is this a composed model?: {}".format(
model.properties.is_composed_model))
print("Status: {}".format(model.status))
print("Composed model creation started on: {}".format(
model.training_started_on))
print("Creation completed on: {}".format(model.training_completed_on))
# [END begin_create_composed_model_async]
print("Recognized fields:")
for submodel in model.submodels:
print("The submodel has model ID: {}".format(submodel.model_id))
print(
"...The submodel with form type {} has an average accuracy '{}'"
.format(submodel.form_type, submodel.accuracy))
for name, field in submodel.fields.items():
print(
"...The model found the field '{}' with an accuracy of {}".
format(name, field.accuracy))
# Training result information
for doc in model.training_documents:
print("Document was used to train model with ID: {}".format(
doc.model_id))
print("Document name: {}".format(doc.name))
print("Document status: {}".format(doc.status))
print("Document page count: {}".format(doc.page_count))
print("Document errors: {}".format(doc.errors))
