0
# V3 Adaptive Machine Translation
1

2
Advanced machine translation capabilities using custom datasets and models trained on domain-specific translation pairs. Adaptive MT improves translation accuracy for specialized contexts by learning from user-provided translation examples.
3

4
## Core Import
5

6
```python
7
from google.cloud import translate_v3
8
```
9

10
## Capabilities
11

12
### Dataset Management
13

14
Create and manage adaptive MT datasets containing translation pairs for model training.
15

16
```python { .api }
17
def create_adaptive_mt_dataset(
18
    self,
19
    request=None,
20
    *,
21
    parent=None,
22
    adaptive_mt_dataset=None,
23
    retry=None,
24
    timeout=None,
25
    metadata=()
26
):
27
    """
28
    Creates an Adaptive MT dataset.
29
    
30
    Args:
31
        request (CreateAdaptiveMtDatasetRequest): The request object
32
        parent (str): Project/location resource name
33
        adaptive_mt_dataset (AdaptiveMtDataset): Dataset configuration
34
        retry: Retry configuration
35
        timeout (float): Request timeout in seconds
36
        metadata: Additional metadata
37
    
38
    Returns:
39
        AdaptiveMtDataset: Created dataset resource
40
    """
41

42
def list_adaptive_mt_datasets(
43
    self,
44
    request=None,
45
    *,
46
    parent=None,
47
    page_size=None,
48
    page_token=None,
49
    filter=None,
50
    retry=None,
51
    timeout=None,
52
    metadata=()
53
):
54
    """
55
    Lists all Adaptive MT datasets for which the caller has read permission.
56
    
57
    Args:
58
        request (ListAdaptiveMtDatasetsRequest): The request object
59
        parent (str): Project/location resource name
60
        page_size (int): Maximum number of datasets to return
61
        page_token (str): Token for pagination
62
        filter (str): Filter expression for datasets
63
        retry: Retry configuration
64
        timeout (float): Request timeout in seconds
65
        metadata: Additional metadata
66
    
67
    Returns:
68
        ListAdaptiveMtDatasetsResponse: Paginated list of datasets
69
    """
70

71
def get_adaptive_mt_dataset(
72
    self,
73
    request=None,
74
    *,
75
    name=None,
76
    retry=None,
77
    timeout=None,
78
    metadata=()
79
):
80
    """
81
    Gets the Adaptive MT dataset.
82
    
83
    Args:
84
        request (GetAdaptiveMtDatasetRequest): The request object
85
        name (str): Dataset resource name
86
        retry: Retry configuration
87
        timeout (float): Request timeout in seconds
88
        metadata: Additional metadata
89
    
90
    Returns:
91
        AdaptiveMtDataset: Dataset resource
92
    """
93

94
def delete_adaptive_mt_dataset(
95
    self,
96
    request=None,
97
    *,
98
    name=None,
99
    retry=None,
100
    timeout=None,
101
    metadata=()
102
):
103
    """
104
    Deletes an Adaptive MT dataset, including all its entries and associated metadata.
105
    
106
    Args:
107
        request (DeleteAdaptiveMtDatasetRequest): The request object
108
        name (str): Dataset resource name
109
        retry: Retry configuration
110
        timeout (float): Request timeout in seconds
111
        metadata: Additional metadata
112
    
113
    Returns:
114
        None
115
    """
116
```
117

118
### Adaptive Translation
119

120
Perform translation using adaptive MT models trained on custom datasets.
121

122
```python { .api }
123
def adaptive_mt_translate(
124
    self,
125
    request=None,
126
    *,
127
    parent=None,
128
    dataset=None,
129
    content=None,
130
    retry=None,
131
    timeout=None,
132
    metadata=()
133
):
134
    """
135
    Translate text using Adaptive MT.
136
    
137
    Args:
138
        request (AdaptiveMtTranslateRequest): The request object
139
        parent (str): Project/location resource name
140
        dataset (str): Adaptive MT dataset resource name
141
        content (list): Text content to translate
142
        retry: Retry configuration
143
        timeout (float): Request timeout in seconds
144
        metadata: Additional metadata
145
    
146
    Returns:
147
        AdaptiveMtTranslateResponse: Adaptive translation results
148
    """
149
```
150

151
### File Management
152

153
Import and manage translation files within adaptive MT datasets.
154

155
```python { .api }
156
def import_adaptive_mt_file(
157
    self,
158
    request=None,
159
    *,
160
    parent=None,
161
    file_input_source=None,
162
    retry=None,
163
    timeout=None,
164
    metadata=()
165
):
166
    """
167
    Imports an AdaptiveMtFile and adds all of its sentences into the dataset.
168
    
169
    Args:
170
        request (ImportAdaptiveMtFileRequest): The request object
171
        parent (str): Dataset resource name
172
        file_input_source (FileInputSource): File input configuration
173
        retry: Retry configuration
174
        timeout (float): Request timeout in seconds
175
        metadata: Additional metadata
176
    
177
    Returns:
178
        ImportAdaptiveMtFileResponse: Import operation result
179
    """
180

181
def list_adaptive_mt_files(
182
    self,
183
    request=None,
184
    *,
185
    parent=None,
186
    page_size=None,
187
    page_token=None,
188
    retry=None,
189
    timeout=None,
190
    metadata=()
191
):
192
    """
193
    Lists all AdaptiveMtFiles associated to this dataset.
194
    
195
    Args:
196
        request (ListAdaptiveMtFilesRequest): The request object
197
        parent (str): Dataset resource name
198
        page_size (int): Maximum number of files to return
199
        page_token (str): Token for pagination
200
        retry: Retry configuration
201
        timeout (float): Request timeout in seconds
202
        metadata: Additional metadata
203
    
204
    Returns:
205
        ListAdaptiveMtFilesResponse: Paginated list of files
206
    """
207

208
def get_adaptive_mt_file(
209
    self,
210
    request=None,
211
    *,
212
    name=None,
213
    retry=None,
214
    timeout=None,
215
    metadata=()
216
):
217
    """
218
    Gets and AdaptiveMtFile.
219
    
220
    Args:
221
        request (GetAdaptiveMtFileRequest): The request object
222
        name (str): File resource name
223
        retry: Retry configuration
224
        timeout (float): Request timeout in seconds
225
        metadata: Additional metadata
226
    
227
    Returns:
228
        AdaptiveMtFile: File resource
229
    """
230

231
def delete_adaptive_mt_file(
232
    self,
233
    request=None,
234
    *,
235
    name=None,
236
    retry=None,
237
    timeout=None,
238
    metadata=()
239
):
240
    """
241
    Deletes an AdaptiveMtFile along with its sentences.
242
    
243
    Args:
244
        request (DeleteAdaptiveMtFileRequest): The request object
245
        name (str): File resource name
246
        retry: Retry configuration
247
        timeout (float): Request timeout in seconds
248
        metadata: Additional metadata
249
    
250
    Returns:
251
        None
252
    """
253
```
254

255
### Sentence Management
256

257
Access and manage individual translation sentence pairs within adaptive MT datasets.
258

259
```python { .api }
260
def list_adaptive_mt_sentences(
261
    self,
262
    request=None,
263
    *,
264
    parent=None,
265
    page_size=None,
266
    page_token=None,
267
    retry=None,
268
    timeout=None,
269
    metadata=()
270
):
271
    """
272
    Lists all AdaptiveMtSentences under a given file/dataset.
273
    
274
    Args:
275
        request (ListAdaptiveMtSentencesRequest): The request object
276
        parent (str): Dataset or file resource name
277
        page_size (int): Maximum number of sentences to return
278
        page_token (str): Token for pagination
279
        retry: Retry configuration
280
        timeout (float): Request timeout in seconds
281
        metadata: Additional metadata
282
    
283
    Returns:
284
        ListAdaptiveMtSentencesResponse: Paginated list of sentences
285
    """
286
```
287

288
## Usage Examples
289

290
### Creating an Adaptive MT Dataset
291

292
```python
293
from google.cloud import translate_v3
294

295
client = translate_v3.TranslationServiceClient()
296

297
parent = "projects/my-project/locations/us-central1"
298

299
dataset = {
300
    "name": "my-adaptive-dataset",
301
    "display_name": "My Adaptive MT Dataset",
302
    "source_language_code": "en",
303
    "target_language_code": "es",
304
}
305

306
response = client.create_adaptive_mt_dataset(
307
    request={
308
        "parent": parent,
309
        "adaptive_mt_dataset": dataset,
310
    }
311
)
312

313
print(f"Created dataset: {response.name}")
314
print(f"Display name: {response.display_name}")
315
print(f"Source language: {response.source_language_code}")
316
print(f"Target language: {response.target_language_code}")
317
```
318

319
### Importing Translation Files
320

321
```python
322
from google.cloud import translate_v3
323

324
client = translate_v3.TranslationServiceClient()
325

326
dataset_name = "projects/my-project/locations/us-central1/adaptiveMtDatasets/my-dataset"
327

328
file_input_source = {
329
    "gcs_source": {
330
        "input_uri": "gs://my-bucket/translation-pairs.txt"
331
    },
332
    "mime_type": "text/plain"
333
}
334

335
response = client.import_adaptive_mt_file(
336
    request={
337
        "parent": dataset_name,
338
        "file_input_source": file_input_source,
339
    }
340
)
341

342
print(f"Imported {response.adaptive_mt_file_count} files")
343
print(f"Processed {response.adaptive_mt_sentence_count} sentences")
344
```
345

346
### Adaptive Translation
347

348
```python
349
from google.cloud import translate_v3
350

351
client = translate_v3.TranslationServiceClient()
352

353
parent = "projects/my-project/locations/us-central1"
354
dataset = "projects/my-project/locations/us-central1/adaptiveMtDatasets/my-dataset"
355

356
response = client.adaptive_mt_translate(
357
    request={
358
        "parent": parent,
359
        "dataset": dataset,
360
        "content": ["Hello, world!", "How are you today?"],
361
    }
362
)
363

364
for translation in response.translations:
365
    print(f"Original: {translation.translated_text}")
366
    
367
# Access language codes from response
368
print(f"Detected language: {response.language_code}")
369
```
370

371
### Listing Datasets
372

373
```python
374
from google.cloud import translate_v3
375

376
client = translate_v3.TranslationServiceClient()
377

378
parent = "projects/my-project/locations/us-central1"
379

380
response = client.list_adaptive_mt_datasets(
381
    request={
382
        "parent": parent,
383
        "page_size": 10,
384
    }
385
)
386

387
for dataset in response.adaptive_mt_datasets:
388
    print(f"Dataset: {dataset.name}")
389
    print(f"Display name: {dataset.display_name}")
390
    print(f"Languages: {dataset.source_language_code} -> {dataset.target_language_code}")
391
    print(f"Example count: {dataset.example_count}")
392
    print("---")
393

394
# Handle pagination
395
if response.next_page_token:
396
    next_response = client.list_adaptive_mt_datasets(
397
        request={
398
            "parent": parent,
399
            "page_token": response.next_page_token,
400
        }
401
    )
402
```
403

404
### Managing Files and Sentences
405

406
```python
407
from google.cloud import translate_v3
408

409
client = translate_v3.TranslationServiceClient()
410

411
dataset_name = "projects/my-project/locations/us-central1/adaptiveMtDatasets/my-dataset"
412

413
# List files in dataset
414
files_response = client.list_adaptive_mt_files(
415
    request={"parent": dataset_name}
416
)
417

418
for file in files_response.adaptive_mt_files:
419
    print(f"File: {file.name}")
420
    print(f"Display name: {file.display_name}")
421
    print(f"Entry count: {file.entry_count}")
422
    
423
    # List sentences in this file
424
    sentences_response = client.list_adaptive_mt_sentences(
425
        request={
426
            "parent": file.name,
427
            "page_size": 5,
428
        }
429
    )
430
    
431
    for sentence in sentences_response.adaptive_mt_sentences:
432
        print(f"Source: {sentence.source_sentence}")
433
        print(f"Target: {sentence.target_sentence}")
434
    
435
    print("---")
436
```