static async Task DetectChangePoint(IAnomalyDetectorClient client, Request request) { Console.WriteLine("Detecting the change points in the series."); var cpdr = new ChangePointDetectRequest(request.Series, request.Granularity); ChangePointDetectResponse result = await client.ChangePointDetectAsync(cpdr).ConfigureAwait(false); if (result.IsChangePoint.Contains(true)) { Console.WriteLine("A change point was detected at index:"); for (int i = 0; i < request.Series.Count; ++i) { if (result.IsChangePoint[i]) { Console.Write(i); Console.Write(" "); } } Console.WriteLine(); } else { Console.WriteLine("No change point detected in the series."); } }
public async Task DetectChangePoint() { //read endpoint and apiKey string endpoint = TestEnvironment.Endpoint; string apiKey = TestEnvironment.ApiKey; var endpointUri = new Uri(endpoint); var credential = new AzureKeyCredential(apiKey); //create client AnomalyDetectorClient client = new AnomalyDetectorClient(endpointUri, credential); #region Snippet:ReadSeriesDataForChangePoint //read data string datapath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "samples", "data", "request-data.csv"); List <TimeSeriesPoint> list = File.ReadAllLines(datapath, Encoding.UTF8) .Where(e => e.Trim().Length != 0) .Select(e => e.Split(',')) .Where(e => e.Length == 2) .Select(e => new TimeSeriesPoint(float.Parse(e[1])) { Timestamp = DateTime.Parse(e[0]) }).ToList(); //create request ChangePointDetectRequest request = new ChangePointDetectRequest(list, TimeGranularity.Daily); #endregion #region Snippet:DetectChangePoint //detect Console.WriteLine("Detecting the change point in the series."); ChangePointDetectResponse result = await client.DetectChangePointAsync(request).ConfigureAwait(false); if (result.IsChangePoint.Contains(true)) { Console.WriteLine("A change point was detected at index:"); for (int i = 0; i < request.Series.Count; ++i) { if (result.IsChangePoint[i]) { Console.Write(i); Console.Write(" "); } } Console.WriteLine(); } else { Console.WriteLine("No change point detected in the series."); } #endregion }
public virtual Response <ChangePointDetectResponse> DetectChangePoint(ChangePointDetectRequest body, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("AnomalyDetectorClient.DetectChangePoint"); scope.Start(); try { return(RestClient.DetectChangePoint(body, cancellationToken)); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Detect change point for the entire series /// </summary> /// <remarks> /// Evaluate change point score of every series point /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='body'> /// Time series points and granularity is needed. Advanced model parameters can /// also be set in the request if needed. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <ChangePointDetectResponse> ChangePointDetectAsync(this IAnomalyDetectorClient operations, ChangePointDetectRequest body, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.ChangePointDetectWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public virtual async Task <Response <ChangePointDetectResponse> > DetectChangePointAsync(ChangePointDetectRequest body, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("AnomalyDetectorClient.DetectChangePoint"); scope.Start(); try { return(await RestClient.DetectChangePointAsync(body, cancellationToken).ConfigureAwait(false)); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Detect change point for the entire series /// </summary> /// <remarks> /// Evaluate change point score of every series point /// </remarks> /// <param name='body'> /// Time series points and granularity is needed. Advanced model parameters can /// also be set in the request if needed. /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="APIErrorException"> /// Thrown when the operation returned an invalid status code /// </exception> /// <exception cref="SerializationException"> /// Thrown when unable to deserialize the response /// </exception> /// <exception cref="ValidationException"> /// Thrown when a required parameter is null /// </exception> /// <exception cref="System.ArgumentNullException"> /// Thrown when a required parameter is null /// </exception> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <HttpOperationResponse <ChangePointDetectResponse> > ChangePointDetectWithHttpMessagesAsync(ChangePointDetectRequest body, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (Endpoint == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Endpoint"); } if (body == null) { throw new ValidationException(ValidationRules.CannotBeNull, "body"); } if (body != null) { body.Validate(); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("body", body); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "ChangePointDetect", tracingParameters); } // Construct URL var _baseUrl = BaseUri; var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "timeseries/changePoint/detect"; _url = _url.Replace("{Endpoint}", Endpoint); // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("POST"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (body != null) { _requestContent = SafeJsonConvert.SerializeObject(body, SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8); _httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200) { var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); APIError _errorBody = SafeJsonConvert.DeserializeObject <APIError>(_responseContent, DeserializationSettings); if (_errorBody != null) { ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new HttpOperationResponse <ChangePointDetectResponse>(); _result.Request = _httpRequest; _result.Response = _httpResponse; // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = SafeJsonConvert.DeserializeObject <ChangePointDetectResponse>(_responseContent, DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }