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
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/service/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// What-if analysis is a scenario modeling technique where you make a hypothetical
// change to a time series and compare the forecasts generated by these changes
// against the baseline, unchanged time series. It is important to remember that
// the purpose of a what-if analysis is to understand how a forecast can change
// given different modifications to the baseline time series.
//
// For example, imagine you are a clothing retailer who is considering an end of
// season sale to clear space for new styles. After creating a baseline forecast,
// you can use a what-if analysis to investigate how different sales tactics might
// affect your goals.
//
// You could create a scenario where everything is given a 25% markdown, and
// another where everything is given a fixed dollar markdown. You could create a
// scenario where the sale lasts for one week and another where the sale lasts for
// one month. With a what-if analysis, you can compare many different scenarios
// against each other.
//
// Note that a what-if analysis is meant to display what the forecasting model has
// learned and how it will behave in the scenarios that you are evaluating. Do not
// blindly use the results of the what-if analysis to make business decisions. For
// instance, forecasts might not be accurate for novel scenarios where there is no
// reference available to determine whether a forecast is good.
//
// The TimeSeriesSelector object defines the items that you want in the what-if analysis.
func (c *Client) CreateWhatIfAnalysis(ctx context.Context, params *CreateWhatIfAnalysisInput, optFns ...func(*Options)) (*CreateWhatIfAnalysisOutput, error) {
if params == nil {
params = &CreateWhatIfAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWhatIfAnalysis", params, optFns, c.addOperationCreateWhatIfAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWhatIfAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWhatIfAnalysisInput struct {
// The Amazon Resource Name (ARN) of the baseline forecast.
//
// This member is required.
ForecastArn *string
// The name of the what-if analysis. Each name must be unique.
//
// This member is required.
WhatIfAnalysisName *string
// A list of [tags] to apply to the what if forecast.
//
// [tags]: https://docs.aws.amazon.com/forecast/latest/dg/tagging-forecast-resources.html
Tags []types.Tag
// Defines the set of time series that are used in the what-if analysis with a
// TimeSeriesIdentifiers object. What-if analyses are performed only for the time
// series in this object.
//
// The TimeSeriesIdentifiers object needs the following information:
//
// - DataSource
//
// - Format
//
// - Schema
TimeSeriesSelector *types.TimeSeriesSelector
noSmithyDocumentSerde
}
type CreateWhatIfAnalysisOutput struct {
// The Amazon Resource Name (ARN) of the what-if analysis.
WhatIfAnalysisArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWhatIfAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateWhatIfAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateWhatIfAnalysis{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "CreateWhatIfAnalysis"); 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 = addClientRequestID(stack); err != nil {
return err
}
if err = addComputeContentLength(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = addComputePayloadSHA256(stack); err != nil {
return err
}
if err = addRetry(stack, options); err != nil {
return err
}
if err = addRawResponseToMetadata(stack); err != nil {
return err
}
if err = 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 = addTimeOffsetBuild(stack, c); err != nil {
return err
}
if err = addUserAgentRetryMode(stack, options); err != nil {
return err
}
if err = addOpCreateWhatIfAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWhatIfAnalysis(options.Region), middleware.Before); err != nil {
return err
}
if err = 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_opCreateWhatIfAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "CreateWhatIfAnalysis",
}
}
|
