1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package transcribe
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/transcribe/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new custom language model. When creating a new custom language model,
// you must specify:
// - If you want a Wideband (audio sample rates over 16,000 Hz) or Narrowband
// (audio sample rates under 16,000 Hz) base model
// - The location of your training and tuning files (this must be an Amazon S3
// URI)
// - The language of your model
// - A unique name for your model
func (c *Client) CreateLanguageModel(ctx context.Context, params *CreateLanguageModelInput, optFns ...func(*Options)) (*CreateLanguageModelOutput, error) {
if params == nil {
params = &CreateLanguageModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateLanguageModel", params, optFns, c.addOperationCreateLanguageModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateLanguageModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateLanguageModelInput struct {
// The Amazon Transcribe standard language model, or base model, used to create
// your custom language model. Amazon Transcribe offers two options for base
// models: Wideband and Narrowband. If the audio you want to transcribe has a
// sample rate of 16,000 Hz or greater, choose WideBand . To transcribe audio with
// a sample rate less than 16,000 Hz, choose NarrowBand .
//
// This member is required.
BaseModelName types.BaseModelName
// Contains the Amazon S3 location of the training data you want to use to create
// a new custom language model, and permissions to access this location. When using
// InputDataConfig , you must include these sub-parameters: S3Uri , which is the
// Amazon S3 location of your training data, and DataAccessRoleArn , which is the
// Amazon Resource Name (ARN) of the role that has permission to access your
// specified Amazon S3 location. You can optionally include TuningDataS3Uri , which
// is the Amazon S3 location of your tuning data. If you specify different Amazon
// S3 locations for training and tuning data, the ARN you use must have permissions
// to access both locations.
//
// This member is required.
InputDataConfig *types.InputDataConfig
// The language code that represents the language of your model. Each custom
// language model must contain terms in only one language, and the language you
// select for your custom language model must match the language of your training
// and tuning data. For a list of supported languages and their associated language
// codes, refer to the Supported languages (https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html)
// table. Note that US English ( en-US ) is the only language supported with Amazon
// Transcribe Medical. A custom language model can only be used to transcribe files
// in the same language as the model. For example, if you create a custom language
// model using US English ( en-US ), you can only apply this model to files that
// contain English audio.
//
// This member is required.
LanguageCode types.CLMLanguageCode
// A unique name, chosen by you, for your custom language model. This name is case
// sensitive, cannot contain spaces, and must be unique within an Amazon Web
// Services account. If you try to create a new custom language model with the same
// name as an existing custom language model, you get a ConflictException error.
//
// This member is required.
ModelName *string
// Adds one or more custom tags, each in the form of a key:value pair, to a new
// custom language model at the time you create this new model. To learn more about
// using tags with Amazon Transcribe, refer to Tagging resources (https://docs.aws.amazon.com/transcribe/latest/dg/tagging.html)
// .
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateLanguageModelOutput struct {
// The Amazon Transcribe standard language model, or base model, you specified
// when creating your custom language model.
BaseModelName types.BaseModelName
// Lists your data access role ARN (Amazon Resource Name) and the Amazon S3
// locations you provided for your training ( S3Uri ) and tuning ( TuningDataS3Uri
// ) data.
InputDataConfig *types.InputDataConfig
// The language code you selected for your custom language model.
LanguageCode types.CLMLanguageCode
// The name of your custom language model.
ModelName *string
// The status of your custom language model. When the status displays as COMPLETED
// , your model is ready to use.
ModelStatus types.ModelStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateLanguageModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateLanguageModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateLanguageModel{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "CreateLanguageModel"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addOpCreateLanguageModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateLanguageModel(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateLanguageModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "CreateLanguageModel",
}
}
|
