public void Cluster() { using (var status = StatusWrapper.NewStatus("DBScan", this.Data.Count)) { //Console.WriteLine(this.RangeDiameter); this.RangeList = TimeCalculator .GetIndexRangeByTimeInterval(this.Data.Select(x => x.TimeTick).ToList(), RangeRadius); for (int i = 0; i < this.Data.Count; i++) { if (this.Data[i].ClusterId > 0) { continue; } CurrentCluster = this.InnerClustering(i); int t = 0; while (t < this.CurrentCluster.Count) { var tl = this.InnerClustering(this.CurrentCluster[t++]); if (tl.Any()) { this.CurrentCluster.AddRange(tl); } } status.PushProgress(this.CurrentCluster.Count); } } this.Validation(); }
private void BuildNeighbors() { using (var status = StatusWrapper.NewStatus("Building Neighbors", this.Data.Count)) { var heap = new EasyHeapSmallFixedSize <NearestNeighbor>(HeapType.MinHeap, withTop, x => x.Distance); var rangeList = TimeCalculator.GetIndexRangeByTimeInterval(this.Data.Select(x => x.TimeTick).ToList(), Convert.ToInt64(kDisDiameter.TotalSeconds)); for (int i = 0; i < this.Data.Count; i++) { this.Data.GetRange(rangeList[i].Item1, rangeList[i].Item2 - rangeList[i].Item1) .ForEach(x => { var g = VectorPointHelper.GetDistance(this.Data[i], x, MathDistance); if (g > 0) { heap.Push(new NearestNeighbor { Distance = g, NeighborIndex = x.Id }); } }); this.Neighbors.Add(heap.GetList().ToList()); status.PushProgress(); } } }
public Task <IDisposable> LockAsync() { lock (_semaphore) { if (_owningStatus.Value?.IsOwner == true) { System.Diagnostics.Debug.WriteLine("owner"); return(Task.FromResult((IDisposable) new Noop())); } var wait = _semaphore.WaitAsync(); if (wait.IsCompleted) { _owningStatus.Value = new StatusWrapper(true); return(_releaser); } else { var statusInst = new StatusWrapper(false); _owningStatus.Value = statusInst; System.Diagnostics.Debug.WriteLine("waiting"); return(wait.ContinueWith( (_, state) => { var status = (StatusWrapper)state; status.IsOwner = true; return _releaser.Result; }, statusInst, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)); } } }
internal int AddStatus(Status NewStatu) { StatusWrapper wrapper = new StatusWrapper (statusId, NewStatu); statusId++; wrapper.status.OnApply (); _toAddStatus.Add (wrapper); return wrapper.id; }
/// <summary> /// Checks if the specified access number is valid for the current user session. /// </summary> /// <param name="accessNumber">The access number.</param> /// <returns> /// A <see cref="Status" /> which indicates whether the access number is valid or no. /// </returns> public Status CheckAccessNumber(string accessNumber) { if (string.IsNullOrEmpty(accessNumber)) { return(new Status(InvalidStatus, ResourceLoader.GetForCurrentView().GetString("NullAccessNumber"))); } StatusWrapper sw = mPtr.CheckAccessNumber(accessNumber); return(new Status(sw.Code, sw.Error)); }
/// <summary> /// Authenticates a <see cref="User" /> against an Access Number provided by a PC/browser session. After this authentication, the user will be able to log-in on to the PC/browser with the provided Access Number while the authentication itself is performed on the user's mobile device. /// </summary> /// <param name="user">The <see cref="User" /> to be authenticated.</param> /// <param name="pin">The PIN of the user.</param> /// <param name="accessNumber">The Access Number provided by the PC/browser session. Required if Access Number authentication is being performed.</param> /// <returns> /// A <see cref="Status" /> which indicates whether the operation was successful or not. /// </returns> public Status FinishAuthenticationAN(User user, string pin, string accessNumber) { Status st = null; if (AreParametersValid(ref st, user, pin, accessNumber)) { StatusWrapper sw = mPtr.FinishAuthenticationAN(user.Wrapper, pin, accessNumber); return(new Status(sw.Code, sw.Error)); } return(st); }
/// <summary> /// Starts the authentication process of a <see cref="User" /> for the needs of the overlaying application. /// </summary> /// <param name="user">The <see cref="User" /> to be authenticated.</param> /// <returns> /// A <see cref="Status" /> which indicates whether the operation was successful or not. /// </returns> public Status StartAuthentication(User user) { Status st = null; if (AreParametersValid(ref st, user)) { StatusWrapper sw = mPtr.StartAuthentication(user.Wrapper); return(new Status(sw.Code, sw.Error)); } return(st); }
private void TSNETransformForFile(string filename) { this.EmbeddingModel.ReadModel(this.EmbeddingModel.GetModelName(filename)); StatusWrapper.NewStatus("Preparing"); var visualizer = new TSNEVisualization { Data = this.DataController.UseData <KeyFeatureClusteredCategorized>(filename).ToList(), Model = this.EmbeddingModel }; //Console.WriteLine(measure.ExternalValidation.Print()); visualizer.toSNE(@"E:\EventExtractionExam\Debug\tSNEcate.csv"); }
/// <summary> /// Finishes the authentication process of a <see cref="User" /> for the needs of the overlaying application. /// </summary> /// <param name="user">The <see cref="User" /> to be authenticated.</param> /// <returns> /// A <see cref="Status" /> which indicates whether the operation was successful or not. /// </returns> public Status FinishAuthentication(User user, string pin, string authResultData = null) { Status st = null; if (AreParametersValid(ref st, user, pin)) { StatusWrapper sw = authResultData == null ? mPtr.FinishAuthentication(user.Wrapper, pin) : mPtr.FinishAuthentication(user.Wrapper, pin, authResultData); return(new Status(sw.Code, sw.Error)); } return(st); }
private void CountErrors() { using (var status = StatusWrapper.NewStatus("Counting", ComparisonList.Count * ((long)ComparisonList.Count - 1) / 2)) { for (int i = 0; i < ComparisonList.Count - 1; i++) { for (int j = i + 1; j < ComparisonList.Count; j++) { status.PushProgress(); //if (i == j) //{ // continue; //} if (ComparisonList[i].Item1 == ComparisonList[j].Item1) { if (ComparisonList[i].Item2 == ComparisonList[j].Item2) { ExternalValidation.TruePositive++; } else { ExternalValidation.FalseNegative++; } } else { if (ComparisonList[i].Item2 == ComparisonList[j].Item2) { ExternalValidation.FalsePositive++; } else { ExternalValidation.TrueNegative++; } } } } } ExternalValidation.Purity = (double)ComparisonList.GroupBy(x => x.Item2) .Sum(x => x.GroupBy(y => y.Item1).Max(y => y.Count())) / ComparisonList.Count; ExternalValidation.NMI = CalculateNMI(); }
/// <summary> /// Authenticates the <see cref="User" /> and, if authentication has been successful, the RPA issues One-Time Password (OTP) for authenticating with a RADIUS server. (The authentication itself doesn’t log the User in: instead, the result of the authentication is the issuing of the OTP.) /// </summary> /// <param name="user">The <see cref="User" /> to be authenticated.</param> /// <param name="pin">The PIN of the user.</param> /// <param name="otp">When the authentication is successful, in addition to the OK status, the method returns also an <see cref="OTP" /> structure generated by the RPA.</param> /// <returns> /// A <see cref="Status" /> which indicates whether the operation was successful or not. /// </returns> public Status FinishAuthenticationOTP(User user, string pin, OTP otp) { if (otp == null) { return(FinishAuthentication(user, pin)); } Status st = null; if (AreParametersValid(ref st, user, pin)) { StatusWrapper sw = mPtr.FinishAuthenticationOTP(user.Wrapper, pin, otp.Wrapper); return(new Status(sw.Code, sw.Error)); } return(st); }
private ClusterExternalValidation ClusteringMeasurementForFile(string filename) { StatusWrapper.NewStatus("Preparing"); var labelList = DataController.UseData <KeyFeatureOfRandomEvent>(filename).ToList(); var resultList = DataController.UseData <KeyFeatureClustered>(EmbeddingModel.GetClusteredFilename(filename)).ToList(); var measure = new ClusteringMeasurement { LabelList = labelList, ResultList = resultList, }; measure.Measure(); //Console.WriteLine(measure.ExternalValidation.Print()); return(measure.ExternalValidation); }
public static void Start(StatusWrapper status) { //if (Worker != null) //{ // Console.WriteLine("Force Cancelling Worker"); // Worker.CancelAsync(); //} //Console.WriteLine("Wait for Worker Reset"); WorkerInBusy.WaitOne(); //Console.WriteLine("Worker Reset!!!"); Status = status; Timer.Restart(); //ProgressBar.Invoke(new InvokeDelegate(SetProgressBarMaximum), status.TotalProgress); StatusLabel.Invoke(new InvokeDelegate(SetStatusLabel), status.CurrentStatus); //ProgressBar.Maximum = Status.TotalProgress; //StatusLabel.Text = Status.CurrentStatus; UpdateProgress(); Worker.RunWorkerAsync(); }
//using AdaGradient private void Train() { // Status using (var status = StatusWrapper.NewStatus(@"Train", this.Cooccurrences.Count * this.NeVeSettings.EpochsCount)) { for (int epoch = 0; epoch < this.NeVeSettings.EpochsCount; epoch++) { this.Loss = 0d; ParallelOptions parallelOptions = new ParallelOptions() { MaxDegreeOfParallelism = this.NeVeSettings.MaximumParallelWorker }; var result = Parallel.For(0, this.NeVeSettings.MaximumParallelWorker, parallelOptions, id => this.AdaGradient(id, status)); if (!result.IsCompleted) { throw new InvalidOperationException(); } Console.WriteLine("Loss = {0}", this.Loss); } } }
private static void Postfix(UnitAttack __instance) { UnitEntityData unit = __instance.Executor; if (!StatusWrapper.IsInCombat() || !unit.IsCurrentUnit()) { return; } bool attackingNearest = unit.Descriptor.State.HasCondition(UnitCondition.AttackNearest); bool confusedAttackNearest = false; if (unit.Descriptor.State.HasCondition(UnitCondition.Confusion)) { UnitPartConfusion part = unit.Get <UnitPartConfusion>(); if (part.State == ConfusionState.AttackNearest) { confusedAttackNearest = true; } } if (attackingNearest || confusedAttackNearest) { StatusWrapper.CurrentTurn().ForceToEnd(); } }
public static void Display(StatusWrapper status) { StatusLabel.Invoke(new InvokeDelegate(SetStatusLabel), status.CurrentStatus); }
private void Train() { using (var status = StatusWrapper.NewStatus(@"Train", this.Data.Count() * this.Ip2VecSettings.EpochsCount)) { // Building training container var sets = new List <TrainingElement>(); foreach (var set in this.Ip2VecSettings.ContextRelationDict) { var target = TrainingElement.NewContainer(this.WordCount, set.Value.Count); sets.Add(target); } for (int i = 0; i < this.Ip2VecSettings.EpochsCount; i++) { this.Loss = 0d; foreach (var item in this.Data) { //this.StatusController.Preparesw.Start(); // Building training elements var c = 0; foreach (var set in this.Ip2VecSettings.ContextRelationDict) { sets[c].RebuildTargetWordVector(W2I(set.Key(item))); sets[c].SetContextWordVector(set.Value.Select(x => W2I(x(item))).ToArray()); c++; } //this.StatusController.Preparesw.Stop(); //this.StatusController.Calcsw.Start(); var index = 0; if (this.Ip2VecSettings.NegativeSampling > 0) { foreach (var set in sets) { this.TrainElementWithNegativeSampling(set); } } else { foreach (var set in sets) { this.TrainElement(set, index++); } } Iter++; status.PushProgress(); //this.StatusController.Calcsw.Stop(); //this.StatusController.SetCurrentProgress(); //if (Iter % 1000 == 0) //{ // this.StatusController.Refresh(); //} //this.Percentage.Value = Iter; //if (this.W1.ToRowMajorArray().Contains(double.NaN)) //{ // MessageBox.Show("NAN error"); //} } Console.WriteLine("loss = " + this.Loss); } #if DEBUG var sb = new StringBuilder(); foreach (var item in this.Ip2VecModel.Index2Word) { sb.AppendLine(string.Format("{0}\t{1}", item.Key, item.Value)); } (new Thread(Record)).Start(new KeyValuePair <string, string>("Dictionary", sb.ToString())); #endif } }
private void PreTrain() { //Distinct this.Data = this.Data.Distinct().ToList(); using (var status = StatusWrapper.NewStatus(@"PreTrain", this.Data.Count)) { // Model Initialization if needed if (this.Ip2VecModel == null) { this.Ip2VecModel = new Ip2VecModel(); } // Negative Sampling Count //var freq = new Dictionary<string, int>(); // Generating trainning data // Generating dictionraies int index = this.Ip2VecModel.Word2Index.Count; foreach (var item in this.Data) { var allfunc = this.Ip2VecSettings.ContextRelationDict.SelectMany(x => x.Value).ToList(); allfunc.AddRange(this.Ip2VecSettings.ContextRelationDict.Keys.ToList()); foreach (var func in allfunc.Distinct()) { var value = func.Invoke(item); if (!this.Ip2VecModel.Word2Index.ContainsKey(value)) { this.Ip2VecModel.Word2Index.Add(value, index); this.Ip2VecModel.Index2Word.Add(index, value); index++; this.Ip2VecModel.Frequency.Add(1); } else { this.Ip2VecModel.Frequency[this.Ip2VecModel.Word2Index[value]]++; } } status.PushProgress(); } this.WordCount = index; } //if (this.Ip2VecSettings.UseRandomInitialization) //{ // Appending Learning Mode w/o new word if (this.Ip2VecModel.W1 != null && this.WordCount == this.Ip2VecModel.W1.RowCount) { this.BuildDiceTable(); return; } this.Ip2VecModel.W1 = Matrix <double> .Build.Dense(this.WordCount, this.Ip2VecSettings.NeuronCount); this.Ip2VecModel.W2 = Matrix <double> .Build.Dense(this.WordCount, this.Ip2VecSettings.NeuronCount); ParallelOptions parallelOptions = new ParallelOptions() { MaxDegreeOfParallelism = this.Ip2VecSettings.MaximumParallelWorker }; var result = Parallel.For(0, this.Ip2VecSettings.MaximumParallelWorker, parallelOptions, this.RandomInitializationParallelWorker); if (!result.IsCompleted) { throw new InvalidOperationException(); } //if (this.Ip2VecModel.W1 != null && this.Ip2VecModel.W2 != null) //{ // for (int i = 0; i < this.Ip2VecModel.W1.RowCount; i++) // { // this.W1.SetRow(i, this.Ip2VecModel.W1.Row(i)); // this.W2.SetRow(i, this.Ip2VecModel.W2.Row(i)); // } //} //this.Ip2VecModel.W1 = this.W1; //this.Ip2VecModel.W2 = this.W2; this.BuildDiceTable(); //} //else //{ // this.Ip2VecModel.W1 = Matrix<double>.Build.Dense(this.WordCount, this.Ip2VecSettings.NeuronCount, (i, j) => 1d / (i * 10d + 2)); // this.Ip2VecModel.W2 = Matrix<double>.Build.Dense(this.WordCount, this.Ip2VecSettings.NeuronCount, (i, j) => 1d / (i * 10d + 2)); //} }
internal void RemoveStatus(StatusWrapper a_appliedStatus) { RemoveStatus (a_appliedStatus.id); }
private void PreTrain() { // Distinct this.Data = this.Data.Distinct().ToList(); this.NeVeModel = new NeVeModel(); StatusWrapper.NewStatus("PreTrain"); // WordCount int index = 0; this.NeVeModel.Word2Index = this.Data .SelectMany(x => Contexts.ContextFuncDict.Values.Select(y => y.Invoke(x))) .Distinct() .ToDictionary(x => x, x => index++); this.WordCount = index; // Build Cooccurrences var cooccurrenceMatrix = new Dictionary <Coordinate <int, int>, double>(); Coordinate <int, int> coordinate; foreach (var sentence in this.Data) { foreach (var relations in this.NeVeSettings.ContextRelationDistanceDict) { foreach (var distancefunc in relations.Value) { //var increment = 1d / distancefunc.Value; //var i = this.Word2Index[relations.Key.Invoke(sentence)]; //var j = this.Word2Index[distancefunc.Key.Invoke(sentence)]; coordinate = Coordinate <int, int> .NewInstance(this.NeVeModel.Word2Index[relations.Key.Invoke(sentence)] , this.NeVeModel.Word2Index[distancefunc.Key.Invoke(sentence)]); if (cooccurrenceMatrix.ContainsKey(coordinate)) { cooccurrenceMatrix[coordinate] += 1d / distancefunc.Value; } else { cooccurrenceMatrix.Add(coordinate, 1d / distancefunc.Value); } //cooccurrenceMatrix[] //cooccurrenceMatrix[this.GloVeModel.Word2Index[relations.Key.Invoke(sentence)] // , this.GloVeModel.Word2Index[distancefunc.Key.Invoke(sentence)]] += 1d / distancefunc.Value; } } } // Build Working Tuples this.Cooccurrences = cooccurrenceMatrix .Select(x => new Tuple <int, int, double>(x.Key.X, x.Key.Y, x.Value)).ToList(); //this.Cooccurrences.Shuffle(); // Build Word Vectors #if DEBUG var r = new Random(Constants.DebugSeed); #else var r = new Random(); #endif for (int i = 0; i < index; i++) { //var row = Vector<double>.Build.Dense(this.GloVeSettings.VectorSize, x => r.NextDouble()); this.NeVeModel.MainVectors.Add(Vector <double> .Build.Dense(this.NeVeSettings.VectorSize, x => (r.NextDouble() - 0.5) / (index + 1))); this.NeVeModel.ContextVectors.Add(Vector <double> .Build.Dense(this.NeVeSettings.VectorSize, x => (r.NextDouble() - 0.5) / (index + 1))); this.MainBias.Add((r.NextDouble() - 0.5) / index + 1); this.ContextBias.Add((r.NextDouble() - 0.5) / index + 1); this.MainGradientSquared.Add(Vector <double> .Build.Dense(this.NeVeSettings.VectorSize, 1)); this.ContextGradientSquared.Add(Vector <double> .Build.Dense(this.NeVeSettings.VectorSize, 1)); this.MainGradientSquaredBias.Add(1); this.ContextGradientSquaredBias.Add(1); } }
private void AdaGradient(int threadid, StatusWrapper status) { int i, j; double co; var weight = 0d; var innercost = 0d; Vector <double> gradMain, gradContext; double gradBias; int interval = Convert.ToInt32(Math.Ceiling(((double)this.Cooccurrences.Count) / this.NeVeSettings.MaximumParallelWorker)); for (int t = threadid * interval; t < interval + threadid * interval && t < this.Cooccurrences.Count; t++) { i = this.Cooccurrences[t].Item1; j = this.Cooccurrences[t].Item2; co = this.Cooccurrences[t].Item3; lock (this.NeVeModel.MainVectors[i]) { lock (this.NeVeModel.ContextVectors[j]) { weight = co < this.NeVeSettings.XMax ? Math.Pow(co / this.NeVeSettings.XMax, .75) : 1; innercost = this.NeVeModel.MainVectors[i].DotProduct(this.NeVeModel.ContextVectors[j]) + this.MainBias[i] + this.ContextBias[j] - Math.Log(co); lock (this.LossLock) { this.Loss += 0.5 * (weight * innercost * innercost); } //Console.WriteLine(this.Loss); //if (double.IsNaN(this.Loss)) //{ // Console.WriteLine(this.Loss); //} gradBias = weight * innercost; gradMain = gradBias * this.NeVeModel.ContextVectors[j]; gradContext = gradBias * this.NeVeModel.MainVectors[i]; this.NeVeModel.MainVectors[i] -= (this.NeVeSettings.LearningRate * gradMain / this.MainGradientSquared[i].PointwiseSqrt()); this.NeVeModel.ContextVectors[j] -= (this.NeVeSettings.LearningRate * gradContext / this.ContextGradientSquared[j].PointwiseSqrt()); this.MainBias[i] -= (this.NeVeSettings.LearningRate * gradBias / Math.Sqrt(this.MainGradientSquaredBias[i])); this.ContextBias[j] -= (this.NeVeSettings.LearningRate * gradBias / Math.Sqrt(this.ContextGradientSquaredBias[j])); this.MainGradientSquared[i] += gradMain.PointwisePower(2); this.ContextGradientSquared[j] += gradContext.PointwisePower(2); this.MainGradientSquaredBias[i] += gradBias * gradBias; this.ContextGradientSquaredBias[j] += gradBias * gradBias; //Console.WriteLine(i + ";" + string.Join(",", this.GloVeModel.MainVectors[i])); //Console.WriteLine(j + ";" + string.Join(",", this.GloVeModel.ContextVectors[j])); } } status.PushProgressSafe(); } }
/// <summary> /// Initializes a new instance of the <see cref="Status"/> class. /// </summary> /// <param name="statusCode">The status code.</param> /// <param name="error">The error message.</param> public Status(int statusCode, String error) { this.Wrapper = new StatusWrapper(); this.StatusCode = (Code)Enum.GetValues(typeof(Code)).GetValue(statusCode); this.ErrorMessage = error; }