public async Task <string> SendRequestAsync(string transactionHash) { var transaction = await _apiTransactionsService.GetTransactionByHash.SendRequestAsync(transactionHash); var transactionInput = transaction.ConvertToTransactionInput(); var functionCallDecoder = new FunctionCallDecoder(); if (transactionInput.MaxFeePerGas != null) { transactionInput.GasPrice = null; } try { var errorHex = await _apiTransactionsService.Call.SendRequestAsync(transactionInput, new BlockParameter(transaction.BlockNumber)); if (ErrorFunction.IsErrorData(errorHex)) { return(functionCallDecoder.DecodeFunctionErrorMessage(errorHex)); } return(string.Empty); } catch (RpcResponseException rpcException) { ContractRevertExceptionHandler.HandleContractRevertException(rpcException); throw; } }
public SsaAnomalyDetectionBase(IHostEnvironment env, ModelLoadContext ctx, string name) : base(env, ctx, name) { // *** Binary format *** // <base> // int: _seasonalWindowSize // float: _discountFactor // byte: _errorFunction // bool: _isAdaptive // AdaptiveSingularSpectrumSequenceModeler: _model Host.CheckDecode(InitialWindowSize == 0); SeasonalWindowSize = ctx.Reader.ReadInt32(); Host.CheckDecode(2 <= SeasonalWindowSize); DiscountFactor = ctx.Reader.ReadSingle(); Host.CheckDecode(0 <= DiscountFactor && DiscountFactor <= 1); byte temp; temp = ctx.Reader.ReadByte(); Host.CheckDecode(Enum.IsDefined(typeof(ErrorFunction), temp)); ErrorFunction = (ErrorFunction)temp; ErrorFunc = ErrorFunctionUtils.GetErrorFunction(ErrorFunction); IsAdaptive = ctx.Reader.ReadBoolean(); StateRef = new State(ctx.Reader); ctx.LoadModel <SequenceModelerBase <Single, Single>, SignatureLoadModel>(env, out Model, "SSA"); Host.CheckDecode(Model != null); StateRef.InitState(this, Host); }
/// <summary> /// Used internally to calculate the error for a training set. /// </summary> /// <param name="trainingSet"> The training set to calculate for. </param> /// <returns> The error value. </returns> private double determineError(DataSet trainingSet) { double result = 0d; IEnumerator <DataSetRow> iterator = trainingSet.iterator(); while (iterator.MoveNext() && !Stopped) { DataSetRow trainingSetRow = iterator.Current; double[] input = trainingSetRow.Input; Network.Input = input; Network.calculate(); double[] output = Network.Output; double[] desiredOutput = trainingSetRow.DesiredOutput; double[] patternError = ErrorFunction.calculatePatternError(desiredOutput, output); double sqrErrorSum = 0; foreach (double error in patternError) { sqrErrorSum += (error * error); } result += sqrErrorSum / (2 * patternError.Length); } return(result); }
public double Cdf(double x) { if (x < 1e-9) { return(0); } return(0.5 * (1 + ErrorFunction.Value((Log(x) - Mean) / (Constants.Sqrt2 * StandardDeviation)))); }
/// <summary> /// Perform SSA spike detection over a column of time series data. See <see cref="SsaSpikeEstimator"/>. /// </summary> public static Vector <double> SsaSpikeDetect( this Scalar <float> input, int confidence, int changeHistoryLength, int trainingWindowSize, int seasonalityWindowSize, AnomalySide side = AnomalySide.TwoSided, ErrorFunction errorFunction = ErrorFunction.SignedDifference ) => new OutColumn(input, confidence, changeHistoryLength, trainingWindowSize, seasonalityWindowSize, side, errorFunction);
// Use this for initialization void Start() { if (this.tag == "finger") { GetJoints(); } ErrorFunction = DistanceFromTarget; }
/// <summary> /// Calculates matched error (out-target) and propagates it through layer to inputs /// </summary> /// <param name="targets">Sequence of targets</param> public virtual List <Matrix <T> > ErrorPropagate(List <Matrix <T> > targets) { if (ErrorFunction == null) { throw new InvalidOperationException("Layer error function is not specified!"); } return(ErrorFunction.BackpropagateError(Outputs, targets)); }
/// <summary> /// Calculates matched layer error. /// </summary> /// <param name="y">Layer output</param> /// <param name="target">Layer target</param> /// <returns></returns> public virtual double LayerError(Matrix <T> y, Matrix <T> target) { if (ErrorFunction == null) { throw new InvalidOperationException("Layer error function is not specified!"); } return(ErrorFunction.GetError(y, target)); }
/// <summary> /// Perform SSA change point detection over a column of time series data. See <see cref="SsaChangePointEstimator"/>. /// </summary> public static Vector <double> SsaChangePointDetect( this Scalar <float> input, int confidence, int changeHistoryLength, int trainingWindowSize, int seasonalityWindowSize, ErrorFunction errorFunction = ErrorFunction.SignedDifference, MartingaleType martingale = MartingaleType.Power, double eps = 0.1) => new OutColumn(input, confidence, changeHistoryLength, trainingWindowSize, seasonalityWindowSize, errorFunction, martingale, eps);
// Use this for initialization void Start() { if (Joints == null) { GetJoints(); } ErrorFunction = DistanceFromTarget; }
public static void MNIST2() { DataSet dataSet = new DataSet("mnist2.txt", ' ', 10, false); var p = new Perceptron(600, 3, ErrorFunction.CrossEntropy()).Layer(784, null).Layer(16, ActivationFunction.Sigmoid()) .Layer(16, ActivationFunction.Sigmoid()).Layer(10, ActivationFunction.Sigmoid()); p.Train2(dataSet, 200); double mse = p.CalculateMeanErrorOverDataSet(dataSet); }
// Use this for initialization void Start() { target = (Vec3)Destination.position; if (Joints == null) { GetJoints(); } ErrorFunction = DistanceFromTarget; }
public OutColumn(Scalar <float> input, int confidence, int pvalueHistoryLength, int trainingWindowSize, int seasonalityWindowSize, AnomalySide side, ErrorFunction errorFunction) : base(new Reconciler(confidence, pvalueHistoryLength, trainingWindowSize, seasonalityWindowSize, side, errorFunction), input) { Input = input; }
public async Task <string> SendRequestAsync(string transactionHash) { var transaction = await _apiTransactionsService.GetTransactionByHash.SendRequestAsync(transactionHash); var errorHex = await _apiTransactionsService.Call.SendRequestAsync(transaction.ConvertToTransactionInput(), new BlockParameter(transaction.BlockNumber)); if (ErrorFunction.IsErrorData(errorHex)) { return(new FunctionCallDecoder().DecodeFunctionErrorMessage(errorHex)); } return(string.Empty); }
public OutColumn(Scalar <float> input, int confidence, int changeHistoryLength, int trainingWindowSize, int seasonalityWindowSize, ErrorFunction errorFunction, MartingaleType martingale, double eps) : base(new Reconciler(confidence, changeHistoryLength, trainingWindowSize, seasonalityWindowSize, errorFunction, martingale, eps), input) { Input = input; }
public double Quantile(Probability p) { if (p < 1e-9) { return(0); } if (p > 1 - 1e-9) { return(double.PositiveInfinity); } return(Exp(Mean + Constants.Sqrt2 * StandardDeviation * ErrorFunction.InverseValue(2 * p - 1))); }
public static IEstimator <ITransformer> _DetectSpikeBySsa(this MLContext MLContext, JToken componentObject) { string outputColumn = componentObject.Value <string>("OutputColumnName"); string inputColumn = componentObject.Value <string>("InputColumnName"); int confidence = componentObject.Value <int>("Confidence"); int pValueHistory = componentObject.Value <int>("PvalueHistoryLength"); int trainingWindow = componentObject.Value <int>("TrainingWindowSize"); int seasonalityWindow = componentObject.Value <int>("SeasonalityWindowSize"); AnomalySide side = Enum.Parse <AnomalySide>(componentObject.Value <string>("AnomalySide")); ErrorFunction errorFunction = Enum.Parse <ErrorFunction>(componentObject.Value <string>("ErrorFunction")); return(MLContext.Transforms.DetectSpikeBySsa(outputColumn, inputColumn, confidence, pValueHistory, trainingWindow, seasonalityWindow, side, errorFunction)); }
public virtual void Save(Stream s) { using (var writer = s.NonGreedyWriter()) { writer.Write(BatchSize); writer.Write(SeqLen); writer.Write(ErrorFunction != null); if (ErrorFunction != null) { writer.Write(ErrorFunction.GetType().FullName); } } }
public Reconciler( int confidence, int pvalueHistoryLength, int trainingWindowSize, int seasonalityWindowSize, AnomalySide side, ErrorFunction errorFunction) { _confidence = confidence; _pvalueHistoryLength = pvalueHistoryLength; _trainingWindowSize = trainingWindowSize; _seasonalityWindowSize = seasonalityWindowSize; _side = side; _errorFunction = errorFunction; }
public static IEstimator <ITransformer> _DetectChangePointBySsa(this MLContext MLContext, JToken componentObject) { string outputColumn = componentObject.Value <string>("OutputColumnName"); string inputColumn = componentObject.Value <string>("InputColumnName"); int confidence = componentObject.Value <int>("Confidence"); int changeHistory = componentObject.Value <int>("ChangeHistoryLength"); int trainingWindow = componentObject.Value <int>("TrainingWindowSize"); int seasonalityWindow = componentObject.Value <int>("SeasonalityWindowSize"); ErrorFunction errorFunction = Enum.Parse <ErrorFunction>(componentObject.Value <string>("ErrorFunction")); MartingaleType martingale = Enum.Parse <MartingaleType>(componentObject.Value <string>("MartingaleType")); double eps = componentObject.Value <double>("Eps"); return(MLContext.Transforms.DetectChangePointBySsa(outputColumn, inputColumn, confidence, changeHistory, trainingWindow, seasonalityWindow, errorFunction, martingale, eps)); }
public Reconciler( int confidence, int changeHistoryLength, int trainingWindowSize, int seasonalityWindowSize, ErrorFunction errorFunction, MartingaleType martingale, double eps) { _confidence = confidence; _changeHistoryLength = changeHistoryLength; _trainingWindowSize = trainingWindowSize; _seasonalityWindowSize = seasonalityWindowSize; _errorFunction = errorFunction; _martingale = martingale; _eps = eps; }
// Use this for initialization void Start() { if (Joints == null) { GetJoints(); } // The error function to minimise if (IsTentacle) { ErrorFunction = delegate(Vector3 target, float[] solution) { PositionRotation result = ForwardKinematics(Solution); // Minimise torsion (rotation on x axis) float torsion = 0; for (int i = 0; i < solution.Length; i++) { torsion += Mathf.Abs(solution[i]) * TorsionPenality.x; torsion += Mathf.Abs(solution[i]) * TorsionPenality.y; torsion += Mathf.Abs(solution[i]) * TorsionPenality.z; } return // The distance (Vector3.Distance(target, result) // The orientation of the effector + Mathf.Abs(Quaternion.Angle(result, Destination.rotation) / 180f) * OrientationWeight // The torsion + (torsion / solution.Length) * TorsionWeight); ; } } ; else { ErrorFunction = DistanceFromTarget; } }
public SsaAnomalyDetectionBase(SsaOptions options, string name, IHostEnvironment env, SsaAnomalyDetectionBaseWrapper parent) : base(options.WindowSize, 0, options.Source, options.Name, name, env, options.Side, options.Martingale, options.AlertOn, options.PowerMartingaleEpsilon, options.AlertThreshold) { Host.CheckUserArg(2 <= options.SeasonalWindowSize, nameof(options.SeasonalWindowSize), "Must be at least 2."); Host.CheckUserArg(0 <= options.DiscountFactor && options.DiscountFactor <= 1, nameof(options.DiscountFactor), "Must be in the range [0, 1]."); Host.CheckUserArg(Enum.IsDefined(typeof(ErrorFunction), options.ErrorFunction), nameof(options.ErrorFunction), ErrorFunctionUtils.ErrorFunctionHelpText); SeasonalWindowSize = options.SeasonalWindowSize; DiscountFactor = options.DiscountFactor; ErrorFunction = options.ErrorFunction; ErrorFunc = ErrorFunctionUtils.GetErrorFunction(ErrorFunction); IsAdaptive = options.IsAdaptive; // Creating the master SSA model Model = new AdaptiveSingularSpectrumSequenceModeler(Host, options.InitialWindowSize, SeasonalWindowSize + 1, SeasonalWindowSize, DiscountFactor, AdaptiveSingularSpectrumSequenceModeler.RankSelectionMethod.Exact, null, SeasonalWindowSize / 2, false, false); StateRef = new State(); StateRef.InitState(WindowSize, InitialWindowSize, this, Host); Parent = parent; }
/// <summary> /// Create a new instance of <see cref="SsaSpikeEstimator"/> /// </summary> /// <param name="env">Host Environment.</param> /// <param name="outputColumnName">Name of the column resulting from the transformation of <paramref name="inputColumnName"/>.</param> /// <param name="confidence">The confidence for spike detection in the range [0, 100].</param> /// <param name="pvalueHistoryLength">The size of the sliding window for computing the p-value.</param> /// <param name="trainingWindowSize">The number of points from the beginning of the sequence used for training.</param> /// <param name="seasonalityWindowSize">An upper bound on the largest relevant seasonality in the input time-series.</param> /// <param name="inputColumnName">Name of column to transform. If set to <see langword="null"/>, the value of the <paramref name="outputColumnName"/> will be used as source. /// The vector contains Alert, Raw Score, P-Value as first three values.</param> /// <param name="side">The argument that determines whether to detect positive or negative anomalies, or both.</param> /// <param name="errorFunction">The function used to compute the error between the expected and the observed value.</param> internal SsaSpikeEstimator(IHostEnvironment env, string outputColumnName, int confidence, int pvalueHistoryLength, int trainingWindowSize, int seasonalityWindowSize, string inputColumnName = null, AnomalySide side = AnomalySide.TwoSided, ErrorFunction errorFunction = ErrorFunction.SignedDifference) : this(env, new SsaSpikeDetector.Options { Source = inputColumnName ?? outputColumnName, Name = outputColumnName, Confidence = confidence, PvalueHistoryLength = pvalueHistoryLength, TrainingWindowSize = trainingWindowSize, SeasonalWindowSize = seasonalityWindowSize, Side = side, ErrorFunction = errorFunction }) { }
/// <summary> /// Create a new instance of <see cref="SsaChangePointEstimator"/> /// </summary> /// <param name="env">Host Environment.</param> /// <param name="outputColumnName">Name of the column resulting from the transformation of <paramref name="inputColumnName"/>. /// Column is a vector of type double and size 4. The vector contains Alert, Raw Score, P-Value and Martingale score as first four values.</param> /// <param name="confidence">The confidence for change point detection in the range [0, 100].</param> /// <param name="trainingWindowSize">The number of points from the beginning of the sequence used for training.</param> /// <param name="changeHistoryLength">The size of the sliding window for computing the p-value.</param> /// <param name="seasonalityWindowSize">An upper bound on the largest relevant seasonality in the input time-series.</param> /// <param name="inputColumnName">Name of column to transform. If set to <see langword="null"/>, the value of the <paramref name="outputColumnName"/> will be used as source.</param> /// <param name="errorFunction">The function used to compute the error between the expected and the observed value.</param> /// <param name="martingale">The martingale used for scoring.</param> /// <param name="eps">The epsilon parameter for the Power martingale.</param> internal SsaChangePointEstimator(IHostEnvironment env, string outputColumnName, int confidence, int changeHistoryLength, int trainingWindowSize, int seasonalityWindowSize, string inputColumnName = null, ErrorFunction errorFunction = ErrorFunction.SignedDifference, MartingaleType martingale = MartingaleType.Power, double eps = 0.1) : this(env, new SsaChangePointDetector.Options { Name = outputColumnName, Source = inputColumnName ?? outputColumnName, Confidence = confidence, ChangeHistoryLength = changeHistoryLength, TrainingWindowSize = trainingWindowSize, SeasonalWindowSize = seasonalityWindowSize, Martingale = martingale, PowerMartingaleEpsilon = eps, ErrorFunction = errorFunction }) { }
public static Func <Double, Double, Double> GetErrorFunction(ErrorFunction errorFunction) { switch (errorFunction) { case ErrorFunction.SignedDifference: return(SignedDifference); case ErrorFunction.AbsoluteDifference: return(AbsoluteDifference); case ErrorFunction.SignedProportion: return(SignedProportion); case ErrorFunction.AbsoluteProportion: return(AbsoluteProportion); case ErrorFunction.SquaredDifference: return(SquaredDifference); default: throw Contracts.Except(ErrorFunctionHelpText); } }
public static void FillResults(ILPanel panel, Panel panelFuzzySets, NeuralNetwork ann) { SetFuzzySets(panelFuzzySets, ann); int xmin = (int)ann.Instance.Samples[0].Variables[0]; int xmax = (int)ann.Instance.Samples[ann.Instance.NumSamples - 1].Variables[0]; int ymin = (int)ann.Instance.Samples[0].Variables[1]; int ymax = (int)ann.Instance.Samples[ann.Instance.NumSamples - 1].Variables[0]; ErrorFunction er = new ErrorFunction(ann.Instance.Samples, ann); ILPlotCube cube = new ILPlotCube(twoDMode: false) { // rotate plot cube Rotation = Matrix4.Rotation(new Vector3(-1, 1, .1f), 0.4f), // perspective projection Projection = Projection.Perspective, Children = { new ILSurface((x, y) => (float)Convert(er.ValueAt, x, y), xmin, xmax, xmax - xmin + 1, ymin, ymax, ymax - ymin + 1, (x, y) => x * y, colormap: Colormaps.Hsv) { UseLighting = true } } }; panel.Scene.Remove(panel.Scene.First <ILPlotCube>()); panel.Scene.Add(cube); panel.Scene.Screen.Add(new ILLabel("Error per sample") { Position = new Vector3(1, 0, 0), Anchor = new PointF(1, 0) }); panel.Refresh(); }
/// <summary> /// Return the percentile (i.e. cdf) at value test_statistic = q where test_statistic ~ N(0, 1) /// </summary> /// <param name="q"></param> /// <returns></returns> public static double GetPercentile2(double q) { return(0.5 + 0.5 * ErrorFunction.GetErf(q / Constants.Sqrt2)); }
public override double GetCDF(double x) { return(0.5 + 0.5 * ErrorFunction.GetErf((x - mMean) / (Constants.Sqrt2 * mStdDev))); }
public static double Quantile(double p, double m, double s) { return(m + s * ErrorFunction.QuantileOfNormalDistribution01(p)); }
public void set_train_error_function(ErrorFunction train_error_function) { fanndoublePINVOKE.neural_net_set_train_error_function(swigCPtr, (int)train_error_function); }
public Vector Solve(ErrorFunction errorFunction, Vector initialGuess) { if (initialGuess.Size != NumVariables) { throw new MatrixException("Size of the initial guess vector is not correct"); } var vector = new Vector(initialGuess); NumStepsToConverge = 0; Vector result; for (var i = 0; i < 20; i++) { var matrix = CalculateJacobian(errorFunction, vector); var vec = errorFunction(vector); var matrix2 = matrix.Transpose(); var squareMatrix = new SquareMatrix(matrix2*matrix); var vec2 = matrix2*vec; var vector2 = squareMatrix.PseudoInverse()*vec2; vector -= vector2; if (IsDone(vector2)) { NumStepsToConverge = i + 1; result = vector; return result; } } result = vector; return result; }
private Matrix CalculateJacobian(ErrorFunction errorFunction, Vector guess) { var matrix = new Matrix(NumEquations, NumVariables); for (var i = 0; i < matrix.Columns; i++) { var num = (Math.Abs(guess[i]) >= 1.0) ? (Math.Abs(guess[i])*1E-07) : 1E-07; var vector = new Vector(guess); Vector vector2; int index; (vector2 = vector)[index = i] = vector2[index] + num; var v = errorFunction(vector); Vector vector3; int index2; (vector3 = vector)[index2 = i] = vector3[index2] - 2.0*num; var v2 = errorFunction(vector); var vec = v - v2; matrix.SetColumn(i, vec/(2.0*num)); } return matrix; }