0
# Classifier Management Operations
1

2
Document classifier lifecycle management for automated document type classification and routing. Includes building, copying, and managing custom classifiers that can identify document types and direct them to appropriate processing workflows with support for multi-class document categorization.
3

4
## Capabilities
5

6
### Classifier Building
7

8
Creates custom document classifiers that can automatically identify and categorize document types, enabling intelligent document routing and processing workflows.
9

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

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

21
    Returns:
22
    LROPoller[DocumentClassifierDetails]: Classifier building operation poller
23
    """
24
```
25

26
Usage example:
27

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

35
# Build classifier for document type detection
36
build_request = BuildDocumentClassifierRequest(
37
    classifier_id="doc-type-classifier",
38
    description="Classifies invoices, receipts, and contracts",
39
    doc_types={
40
        "invoice": ClassifierDocumentTypeDetails(
41
            azure_blob_source=AzureBlobContentSource(
42
                container_url="https://account.blob.core.windows.net/invoices"
43
            )
44
        ),
45
        "receipt": ClassifierDocumentTypeDetails(
46
            azure_blob_source=AzureBlobContentSource(
47
                container_url="https://account.blob.core.windows.net/receipts"
48
            )
49
        ),
50
        "contract": ClassifierDocumentTypeDetails(
51
            azure_blob_source=AzureBlobContentSource(
52
                container_url="https://account.blob.core.windows.net/contracts"
53
            )
54
        )
55
    }
56
)
57

58
poller = admin_client.begin_build_classifier(build_request)
59
classifier = poller.result()
60
print(f"Classifier {classifier.classifier_id} built successfully")
61
```
62

63
### Classifier Information Retrieval
64

65
Retrieves detailed information about trained classifiers including training statistics, document type configurations, and classification capabilities.
66

67
```python { .api }
68
def get_classifier(
69
    classifier_id: str,
70
    **kwargs: Any
71
) -> DocumentClassifierDetails:
72
    """
73
    Gets detailed classifier information.
74

75
    Parameters:
76
    - classifier_id (str): Unique classifier identifier
77

78
    Returns:
79
    DocumentClassifierDetails: Complete classifier metadata and configuration
80
    """
81

82
def list_classifiers(
83
    **kwargs: Any
84
) -> Iterable[DocumentClassifierDetails]:
85
    """
86
    Lists all custom classifiers.
87

88
    Returns:
89
    Iterable[DocumentClassifierDetails]: Paginated classifier collection
90
    """
91
```
92

93
### Classifier Deletion
94

95
Removes custom classifiers from the service to free up classifier quotas and clean up unused classifiers.
96

97
```python { .api }
98
def delete_classifier(
99
    classifier_id: str,
100
    **kwargs: Any
101
) -> None:
102
    """
103
    Deletes a custom classifier.
104

105
    Parameters:
106
    - classifier_id (str): Classifier identifier to delete
107
    """
108
```
109

110
### Classifier Copy Authorization
111

112
Generates authorization tokens for copying classifiers between different Document Intelligence resources, enabling classifier sharing and deployment across environments.
113

114
```python { .api }
115
def authorize_classifier_copy(
116
    body: Union[AuthorizeClassifierCopyRequest, JSON, IO[bytes]],
117
    **kwargs: Any
118
) -> ClassifierCopyAuthorization:
119
    """
120
    Generates authorization for classifier copy operation.
121

122
    Parameters:
123
    - body: Copy authorization request with target resource details
124

125
    Returns:
126
    ClassifierCopyAuthorization: Authorization token and metadata for copy operation
127
    """
128
```
129

130
### Classifier Copying
131

132
Copies classifiers between Document Intelligence resources using authorization tokens, enabling classifier deployment and sharing across different environments.
133

134
```python { .api }
135
def begin_copy_classifier_to(
136
    classifier_id: str,
137
    body: Union[ClassifierCopyAuthorization, JSON, IO[bytes]],
138
    **kwargs: Any
139
) -> LROPoller[DocumentClassifierDetails]:
140
    """
141
    Copies classifier to target resource.
142

143
    Parameters:
144
    - classifier_id (str): Source classifier identifier
145
    - body: Copy authorization from target resource
146

147
    Returns:
148
    LROPoller[DocumentClassifierDetails]: Classifier copy operation poller
149
    """
150
```
151

152
Usage example:
153

154
```python
155
# Step 1: Generate copy authorization on target resource
156
target_admin_client = DocumentIntelligenceAdministrationClient(
157
    endpoint="https://target-resource.cognitiveservices.azure.com/",
158
    credential=AzureKeyCredential("target-api-key")
159
)
160

161
auth_request = AuthorizeClassifierCopyRequest(
162
    classifier_id="copied-classifier-id",
163
    description="Copied document classifier"
164
)
165
copy_auth = target_admin_client.authorize_classifier_copy(auth_request)
166

167
# Step 2: Copy classifier from source resource
168
source_admin_client = DocumentIntelligenceAdministrationClient(
169
    endpoint="https://source-resource.cognitiveservices.azure.com/",
170
    credential=AzureKeyCredential("source-api-key")
171
)
172

173
poller = source_admin_client.begin_copy_classifier_to("source-classifier-id", copy_auth)
174
copied_classifier = poller.result()
175
```
176

177
## Request Types
178

179
```python { .api }
180
class BuildDocumentClassifierRequest:
181
    """Request to build a custom document classifier."""
182
    classifier_id: str
183
    description: Optional[str]
184
    doc_types: Dict[str, ClassifierDocumentTypeDetails]
185
    base_classifier_id: Optional[str]
186

187
class AuthorizeClassifierCopyRequest:
188
    """Request to authorize classifier copying."""
189
    classifier_id: str
190
    description: Optional[str]
191
    tags: Optional[Dict[str, str]]
192

193
class ClassifierDocumentTypeDetails:
194
    """Document type configuration for classifier training."""
195
    azure_blob_source: Optional[AzureBlobContentSource]
196
    azure_blob_file_list_source: Optional[AzureBlobFileListContentSource]
197
```
198

199
## Response Types
200

201
```python { .api }
202
class DocumentClassifierDetails:
203
    """Comprehensive classifier information and metadata."""
204
    classifier_id: str
205
    description: Optional[str]
206
    created_date_time: datetime
207
    expiration_date_time: Optional[datetime]
208
    api_version: str
209
    base_classifier_id: Optional[str]
210
    doc_types: Dict[str, ClassifierDocumentTypeDetails]
211
    warnings: Optional[List[DocumentIntelligenceWarning]]
212

213
class ClassifierCopyAuthorization:
214
    """Authorization for cross-resource classifier copying."""
215
    target_resource_id: str
216
    target_resource_region: str
217
    target_classifier_id: str
218
    target_classifier_location: str
219
    access_token: str
220
    expiration_date_time: datetime
221
```
222

223
## Operation Details Types
224

225
Document classifier operations inherit from the base operation details and provide specialized information for classifier-specific operations.
226

227
```python { .api }
228
class DocumentClassifierBuildOperationDetails(DocumentIntelligenceOperationDetails):
229
    """Classifier build operation details."""
230
    result: Optional[DocumentClassifierDetails]
231
    # Inherits: operation_id, status, created_date_time, etc.
232

233
class DocumentClassifierCopyToOperationDetails(DocumentIntelligenceOperationDetails):
234
    """Classifier copy operation details."""
235
    result: Optional[DocumentClassifierDetails]
236
    # Inherits: operation_id, status, created_date_time, etc.
237
```