0
# Model Management Operations
1

2
Custom document model lifecycle management including building, composing, copying, and managing document models. Supports both template and neural training modes with comprehensive model metadata, operation tracking, and cross-resource model copying capabilities.
3

4
## Capabilities
5

6
### Model Building
7

8
Creates custom document models from training data using template or neural training modes. Template mode works well for consistent document layouts, while neural mode handles diverse document structures.
9

10
```python { .api }
11
def begin_build_document_model(
12
    body: Union[BuildDocumentModelRequest, JSON, IO[bytes]],
13
    **kwargs: Any
14
) -> LROPoller[DocumentModelDetails]:
15
    """
16
    Builds a custom document model.
17

18
    Parameters:
19
    - body: Build request with model configuration and training data
20

21
    Returns:
22
    LROPoller[DocumentModelDetails]: Model building operation poller
23
    """
24
```
25

26
Usage example:
27

28
```python
29
from azure.ai.documentintelligence.models import (
30
    BuildDocumentModelRequest,
31
    AzureBlobContentSource,
32
    DocumentBuildMode
33
)
34

35
# Build neural model for diverse layouts
36
build_request = BuildDocumentModelRequest(
37
    model_id="my-neural-model",
38
    description="Invoice processing model",
39
    build_mode=DocumentBuildMode.NEURAL,
40
    training_data_source=AzureBlobContentSource(
41
        container_url="https://account.blob.core.windows.net/training-data"
42
    ),
43
    tags={"department": "finance", "version": "1.0"}
44
)
45

46
poller = admin_client.begin_build_document_model(build_request)
47
model = poller.result()
48
print(f"Model {model.model_id} built successfully")
49
```
50

51
### Model Composition
52

53
Combines multiple trained models into a single composed model that can intelligently route documents to the appropriate sub-model based on document characteristics.
54

55
```python { .api }
56
def begin_compose_model(
57
    body: Union[ComposeDocumentModelRequest, JSON, IO[bytes]],
58
    **kwargs: Any
59
) -> LROPoller[DocumentModelDetails]:
60
    """
61
    Composes multiple models into a single model.
62

63
    Parameters:
64
    - body: Compose request with component model IDs and configuration
65

66
    Returns:  
67
    LROPoller[DocumentModelDetails]: Model composition operation poller
68
    """
69
```
70

71
Usage example:
72

73
```python
74
from azure.ai.documentintelligence.models import (
75
    ComposeDocumentModelRequest,
76
    ComponentDocumentModelDetails
77
)
78

79
compose_request = ComposeDocumentModelRequest(
80
    model_id="composed-invoice-model",
81
    description="Multi-format invoice model",
82
    component_models=[
83
        ComponentDocumentModelDetails(model_id="invoice-template-1"),
84
        ComponentDocumentModelDetails(model_id="invoice-template-2"),
85
        ComponentDocumentModelDetails(model_id="receipt-model")
86
    ],
87
    tags={"type": "composed", "domain": "invoicing"}
88
)
89

90
poller = admin_client.begin_compose_model(compose_request)
91
composed_model = poller.result()
92
```
93

94
### Model Information Retrieval
95

96
Retrieves detailed information about trained models including training statistics, field schemas, and model capabilities.
97

98
```python { .api }
99
def get_model(
100
    model_id: str,
101
    **kwargs: Any
102
) -> DocumentModelDetails:
103
    """
104
    Gets detailed model information.
105

106
    Parameters:
107
    - model_id (str): Unique model identifier
108

109
    Returns:
110
    DocumentModelDetails: Complete model metadata and configuration
111
    """
112

113
def list_models(
114
    **kwargs: Any
115
) -> Iterable[DocumentModelDetails]:
116
    """
117
    Lists all custom models.
118

119
    Returns:
120
    Iterable[DocumentModelDetails]: Paginated model collection
121
    """
122
```
123

124
### Model Deletion
125

126
Removes custom models from the service to free up model quotas and clean up unused models.
127

128
```python { .api }
129
def delete_model(
130
    model_id: str,
131
    **kwargs: Any
132
) -> None:
133
    """
134
    Deletes a custom model.
135

136
    Parameters:
137
    - model_id (str): Model identifier to delete
138
    """
139
```
140

141
### Model Copy Authorization
142

143
Generates authorization tokens for copying models between different Document Intelligence resources, enabling model sharing and deployment across environments.
144

145
```python { .api }
146
def authorize_model_copy(
147
    body: Union[AuthorizeCopyRequest, JSON, IO[bytes]],
148
    **kwargs: Any
149
) -> ModelCopyAuthorization:
150
    """
151
    Generates authorization for model copy operation.
152

153
    Parameters:
154
    - body: Copy authorization request with target resource details
155

156
    Returns:
157
    ModelCopyAuthorization: Authorization token and metadata for copy operation
158
    """
159
```
160

161
### Model Copying
162

163
Copies models between Document Intelligence resources using authorization tokens, enabling model deployment and sharing across different environments.
164

165
```python { .api }
166
def begin_copy_model_to(
167
    model_id: str,
168
    body: Union[ModelCopyAuthorization, JSON, IO[bytes]],
169
    **kwargs: Any
170
) -> LROPoller[DocumentModelDetails]:
171
    """
172
    Copies model to target resource.
173

174
    Parameters:
175
    - model_id (str): Source model identifier
176
    - body: Copy authorization from target resource
177

178
    Returns:
179
    LROPoller[DocumentModelDetails]: Model copy operation poller
180
    """
181
```
182

183
Usage example:
184

185
```python
186
# Step 1: Generate copy authorization on target resource
187
target_admin_client = DocumentIntelligenceAdministrationClient(
188
    endpoint="https://target-resource.cognitiveservices.azure.com/",
189
    credential=AzureKeyCredential("target-api-key")
190
)
191

192
auth_request = AuthorizeCopyRequest(
193
    model_id="copied-model-id",
194
    description="Copied invoice model"
195
)
196
copy_auth = target_admin_client.authorize_model_copy(auth_request)
197

198
# Step 2: Copy model from source resource
199
source_admin_client = DocumentIntelligenceAdministrationClient(
200
    endpoint="https://source-resource.cognitiveservices.azure.com/",
201
    credential=AzureKeyCredential("source-api-key")
202
)
203

204
poller = source_admin_client.begin_copy_model_to("source-model-id", copy_auth)
205
copied_model = poller.result()
206
```
207

208
## Request Types
209

210
```python { .api }
211
class BuildDocumentModelRequest:
212
    """Request to build a custom document model."""
213
    model_id: str
214
    description: Optional[str]
215
    build_mode: DocumentBuildMode
216
    training_data_source: Union[AzureBlobContentSource, AzureBlobFileListContentSource]
217
    test_data_source: Optional[Union[AzureBlobContentSource, AzureBlobFileListContentSource]]
218
    tags: Optional[Dict[str, str]]
219

220
class ComposeDocumentModelRequest:
221
    """Request to compose multiple models."""
222
    model_id: str
223
    description: Optional[str]
224
    component_models: List[ComponentDocumentModelDetails]
225
    tags: Optional[Dict[str, str]]
226

227
class AuthorizeCopyRequest:
228
    """Request to authorize model copying."""
229
    model_id: str
230
    description: Optional[str]
231
    tags: Optional[Dict[str, str]]
232

233
class ComponentDocumentModelDetails:
234
    """Component model for composition."""
235
    model_id: str
236
```
237

238
## Response Types
239

240
```python { .api }
241
class DocumentModelDetails:
242
    """Comprehensive model information and metadata."""
243
    model_id: str
244
    description: Optional[str]
245
    created_date_time: datetime
246
    expiration_date_time: Optional[datetime]
247
    api_version: str
248
    tags: Optional[Dict[str, str]]
249
    build_mode: Optional[DocumentBuildMode]
250
    azure_blob_source: Optional[AzureBlobContentSource]
251
    azure_blob_file_list_source: Optional[AzureBlobFileListContentSource]
252
    doc_types: Optional[Dict[str, DocumentTypeDetails]]
253
    warnings: Optional[List[DocumentIntelligenceWarning]]
254
    training_hours: Optional[int]
255
    base_model_id: Optional[str]
256

257
class ModelCopyAuthorization:
258
    """Authorization for cross-resource model copying."""
259
    target_resource_id: str
260
    target_resource_region: str
261
    target_model_id: str
262
    target_model_location: str
263
    access_token: str
264
    expiration_date_time: datetime
265

266
class DocumentTypeDetails:
267
    """Document type configuration within a model."""
268
    description: Optional[str]
269
    build_mode: Optional[DocumentBuildMode]
270
    field_schema: Optional[Dict[str, DocumentFieldSchema]]
271
    field_confidence: Optional[Dict[str, float]]
272
```
273

274
## Content Source Types
275

276
```python { .api }
277
class AzureBlobContentSource:
278
    """Azure Blob Storage content source."""
279
    container_url: str
280
    prefix: Optional[str]
281

282
class AzureBlobFileListContentSource:
283
    """Azure Blob Storage file list source."""
284
    container_url: str
285
    file_list: str
286

287
class DocumentFieldSchema:
288
    """Schema definition for document fields."""
289
    type: DocumentFieldType
290
    description: Optional[str]
291
    example: Optional[str]
292
    items: Optional["DocumentFieldSchema"]
293
    properties: Optional[Dict[str, "DocumentFieldSchema"]]
294

295
class CustomDocumentModelsDetails:
296
    """Custom model quota and usage information."""
297
    count: int
298
    limit: int
299
```
300

301
## Service Operations
302

303
```python { .api }
304
def get_resource_details(
305
    **kwargs: Any
306
) -> DocumentIntelligenceResourceDetails:
307
    """
308
    Gets Document Intelligence resource information.
309

310
    Returns:
311
    DocumentIntelligenceResourceDetails: Service resource details and limits
312
    """
313

314
def get_operation(
315
    operation_id: str,
316
    **kwargs: Any
317
) -> DocumentIntelligenceOperationDetails:
318
    """
319
    Gets operation details by ID.
320

321
    Parameters:
322
    - operation_id (str): Long-running operation identifier
323

324
    Returns: 
325
    DocumentIntelligenceOperationDetails: Operation status and metadata
326
    """
327

328
def list_operations(
329
    **kwargs: Any
330
) -> Iterable[DocumentIntelligenceOperationDetails]:
331
    """
332
    Lists all operations.
333

334
    Returns:
335
    Iterable[DocumentIntelligenceOperationDetails]: Paginated operations collection
336
    """
337

338
class DocumentIntelligenceResourceDetails:
339
    """Service resource information."""
340
    custom_document_models: CustomDocumentModelsDetails
341
    custom_neural_document_model_builds: CustomDocumentModelsDetails
342

343
class DocumentIntelligenceOperationDetails:
344
    """Base operation details with status and timing."""
345
    operation_id: str
346
    status: DocumentIntelligenceOperationStatus
347
    percent_completed: Optional[int]
348
    created_date_time: datetime
349
    last_updated_date_time: datetime
350
    kind: OperationKind
351
    resource_location: str
352
    api_version: Optional[str]
353
    tags: Optional[Dict[str, str]]
354
    error: Optional[DocumentIntelligenceError]
355
```