public IPredictionModel BuildModel( IDataFrame dataFrame, int dependentFeatureIndex, IModelBuilderParams additionalParams) { return BuildModel(dataFrame, dataFrame.ColumnNames[dependentFeatureIndex], additionalParams); }
/// <summary> /// Helper function for plotting. /// </summary> private void Plot(string indexColumnName, IDataFrame dataFrame) { var indexValues = dataFrame.GetColumn(indexColumnName).AsDate().ToValues(); var remainingColumns = dataFrame.DropColumn("index").GetColumns(); var allSeriesData = remainingColumns .Select(column => { var label = column.GetName(); var entries = LinqExts.Zip( indexValues, column.AsFloat().ToValues(), (index, value) => new { index, value } ) .ToArray(); return new { label, entries }; }) .ToArray(); foreach (var seriesData in allSeriesData) { var series = new Series(seriesData.label); foreach (var entry in seriesData.entries) { series.Points.AddXY(entry.index, entry.value); } chart1.Series.Add(series); } }
private static BinaryDecisionTreeLink GetSubsetLink(IDataFrame subset, double totalRowsCount, bool testResult) { return new BinaryDecisionTreeLink( subset.Any ? subset.RowCount / totalRowsCount : 0, subset.RowCount, testResult); }
protected override Tuple<IList<ISplittedData>, ISplittingParams, double> EvaluateCategoricalSplit( IDataFrame dataToSplit, string dependentFeatureName, string splittingFeatureName, double bestSplitQualitySoFar, double initialEntropy, ISplitQualityChecker splitQualityChecker, IAlredyUsedAttributesInfo alreadyUsedAttributesInfo) { if (alreadyUsedAttributesInfo.WasAttributeAlreadyUsed(splittingFeatureName)) { return new Tuple<IList<ISplittedData>, ISplittingParams, double>( new List<ISplittedData>(), new SplittingParams(splittingFeatureName, dependentFeatureName), double.NegativeInfinity); } var totalRowsCount = dataToSplit.RowCount; var splitParams = new SplittingParams(splittingFeatureName, dependentFeatureName); var splitData = CategoricalDataSplitter.SplitData(dataToSplit, splitParams); if (splitData.Count == 1) { return new Tuple<IList<ISplittedData>, ISplittingParams, double>( new List<ISplittedData>(), splitParams, double.NegativeInfinity); } var splitQuality = splitQualityChecker.CalculateSplitQuality(initialEntropy, totalRowsCount, splitData, dependentFeatureName); return new Tuple<IList<ISplittedData>, ISplittingParams, double>(splitData, splitParams, splitQuality); }
public double CalculateSplitQuality(IDataFrame baseData, IList<ISplittedData> splittingResults, string dependentFeatureName) { var splittedResultsDependentValues = splittingResults.Select( res => res.SplittedDataFrame.GetNumericColumnVector(dependentFeatureName) as IList<double>).ToList(); var initialEntropy = GetInitialEntropy(baseData, dependentFeatureName); return CalculateSplitQuality(initialEntropy, baseData.RowCount, splittedResultsDependentValues); }
/// <summary> /// Creates a new <see cref="DataCell"/>. /// </summary> /// <param name="parent">The reference to parent <see cref="IDataFrame"/> of this <see cref="DataCell"/>.</param> /// <param name="configurationCell">The <see cref="IConfigurationCell"/> associated with this <see cref="DataCell"/>.</param> public DataCell(IDataFrame parent, IConfigurationCell configurationCell) : base(parent, configurationCell, Common.MaximumPhasorValues, Common.MaximumAnalogValues, Common.MaximumDigitalValues) { // Initialize single phasor value and frequency value with an empty value PhasorValues.Add(new PhasorValue(this, configurationCell.PhasorDefinitions[0])); // Initialize frequency and df/dt FrequencyValue = new FrequencyValue(this, configurationCell.FrequencyDefinition); }
public IList<ISplittedData> SplitData( IDataFrame dataToSplit, ISplittingParams splttingParams) { if (!(splttingParams is IBinarySplittingParams)) { throw new ArgumentException("Invalid splitting params passed to binary splitter"); } return SplitData(dataToSplit, (IBinarySplittingParams) splttingParams); }
public IPredictionModel BuildModel(IDataFrame dataFrame, string dependentFeatureName, IModelBuilderParams additionalParams) { if (!(additionalParams is ILinearRegressionParams)) { throw new ArgumentException("Invalid parameters passed to Regularized Linear Regression model builder!"); } var linearRegressionParams = additionalParams as ILinearRegressionParams; var matrixX = dataFrame.GetSubsetByColumns(dataFrame.ColumnNames.Except(new[] { dependentFeatureName }).ToList()).GetAsMatrixWithIntercept(); var vectorY = dataFrame.GetNumericColumnVector(dependentFeatureName); return BuildModel(matrixX, vectorY, linearRegressionParams); }
/// <summary> /// Creates a new <see cref="DataCell"/>. /// </summary> /// <param name="parent">The reference to parent <see cref="IDataFrame"/> of this <see cref="DataCell"/>.</param> /// <param name="configurationCell">The <see cref="IConfigurationCell"/> associated with this <see cref="DataCell"/>.</param> public DataCell(IDataFrame parent, IConfigurationCell configurationCell) : base(parent, configurationCell, 0x0000, Common.MaximumPhasorValues, Common.MaximumAnalogValues, Common.MaximumDigitalValues) { // Define new parsing state which defines constructors for key data values State = new DataCellParsingState( configurationCell, PhasorValue.CreateNewValue, IEEEC37_118.FrequencyValue.CreateNewValue, AnalogValue.CreateNewValue, DigitalValue.CreateNewValue); }
/// <summary> /// Creates a new <see cref="DataCell"/>. /// </summary> /// <param name="parent">The reference to parent <see cref="IDataFrame"/> of this <see cref="DataCell"/>.</param> /// <param name="configurationCell">The <see cref="IConfigurationCell"/> associated with this <see cref="DataCell"/>.</param> public DataCell(IDataFrame parent, IConfigurationCell configurationCell) : base(parent, configurationCell, Common.MaximumPhasorValues, Common.MaximumAnalogValues, Common.MaximumDigitalValues) { // Define new parsing state which defines constructors for key data values State = new DataCellParsingState( configurationCell, Ieee1344.PhasorValue.CreateNewValue, Ieee1344.FrequencyValue.CreateNewValue, null, // IEEE 1344 doesn't define analogs Ieee1344.DigitalValue.CreateNewValue); }
public Tuple<ISplittingResult, double> FindBestSplitPoint( IDataFrame baseData, string dependentFeatureName, string numericFeatureToProcess, ICategoricalSplitQualityChecker splitQualityChecker, IBinaryNumericDataSplitter binaryNumericDataSplitter, double initialEntropy) { ISplittingResult bestSplit = null; double bestSplitQuality = double.NegativeInfinity; var totalRowsCount = baseData.RowCount; var sortedRowData = baseData.GetNumericColumnVector(numericFeatureToProcess) .AsParallel() .Select((val, rowIdx) => new { RowIdx = rowIdx, FeatureValue = val, DependentFeatureValue = baseData[rowIdx, dependentFeatureName].FeatureValue }) .OrderBy(elem => elem.FeatureValue).ThenBy(elem => elem.RowIdx) .ToList(); var previousClass = sortedRowData[0].DependentFeatureValue; var previousFeatureVal = sortedRowData[0].FeatureValue; foreach (var rowData in sortedRowData) { var currentClass = rowData.DependentFeatureValue; var currentFeatureVal = rowData.FeatureValue; if (!currentClass.Equals(previousClass) && !currentFeatureVal.Equals(previousFeatureVal)) { var halfWay = (previousFeatureVal + currentFeatureVal) / 2.0; var splitParams = new BinarySplittingParams(numericFeatureToProcess, halfWay, dependentFeatureName); var splitResult = binaryNumericDataSplitter.SplitData(baseData, splitParams); var quality = splitQualityChecker.CalculateSplitQuality( initialEntropy, totalRowsCount, splitResult, dependentFeatureName); if (quality >= bestSplitQuality) { bestSplitQuality = quality; bestSplit = new BinarySplittingResult(true, numericFeatureToProcess, splitResult, halfWay); } previousClass = currentClass; } previousFeatureVal = currentFeatureVal; } return new Tuple<ISplittingResult, double>(bestSplit, bestSplitQuality); }
/// <summary> /// Helper function for plotting. /// </summary> private void Plot(string yAxisColumnName, string xAxisColumnName, IDataFrame dataFrame) { var subset = dataFrame.GetColumnsSubset(new string[] { yAxisColumnName, xAxisColumnName }); var series = new Series(xAxisColumnName); foreach (var entry in subset.GetValues<DateTime, float>()) { series.Points.AddXY(entry.Item1, entry.Item2); } this.chart1.Series.Add(series); }
public ISplittingResult SelectBestSplit( IDataFrame baseData, string dependentFeatureName, ISplitQualityChecker splitQualityChecker, IAlredyUsedAttributesInfo alreadyUsedAttributesInfo) { if (!(splitQualityChecker is INumericalSplitQualityChecker)) { throw new ArgumentException("Invalid split quality checker for numerical outcome"); } return SelectBestSplit(baseData, dependentFeatureName, (INumericalSplitQualityChecker)splitQualityChecker, alreadyUsedAttributesInfo); }
public IDictionary<DataType, IList<int>> SplitData(IDataFrame dataFrame, double trainingProportion) { var trainingDataCount = (int) (dataFrame.RowCount * trainingProportion); var shuffledIndices = Enumerable.Range(0, dataFrame.RowCount).ToList().Shuffle(_randomier); var trainingIndices = shuffledIndices.Take(trainingDataCount).ToList(); var testingIndices = shuffledIndices.Skip(trainingDataCount).ToList(); return new Dictionary<DataType, IList<int>> { [DataType.Training] = trainingIndices, [DataType.Testing] = testingIndices }; }
public IList<ISplittedData> SplitData(IDataFrame dataToSplit, IBinarySplittingParams splttingParams) { var queries = BuildQueries(splttingParams.SplitOnFeature, splttingParams.SplitOnValue); var splitResults = new List<ISplittedData>(); var totalRowsCount = (double)dataToSplit.RowCount; foreach (var boolAndQuery in queries) { var resultDataFrame = dataToSplit.GetSubsetByQuery(boolAndQuery.Value); splitResults.Add(new SplittedData(GetSubsetLink(resultDataFrame, totalRowsCount, boolAndQuery.Key), resultDataFrame)); } return splitResults; }
public IDecisionTreeLeaf BuildLeaf(IDataFrame finalData, string dependentFeatureName) { var counts = new Dictionary<object, int>(); var finalValues = finalData.GetColumnVector(dependentFeatureName); foreach (var val in finalValues) { if (!counts.ContainsKey(val)) { counts.Add(val, 0); } counts[val] += 1; } return new DecisionTreeLeaf(dependentFeatureName, counts.OrderBy(kvp => kvp.Value).Reverse().First().Key); }
public bool IsSplitStatisticallySignificant( IDataFrame initialDataFrame, ISplittingResult splittingResults, string dependentFeatureName) { var uniqueDependentValuesCounts = initialDataFrame .GetColumnVector(dependentFeatureName) .Values .GroupBy(elem => elem) .ToDictionary(grp => grp.Key, grp => grp.Count() / (double)initialDataFrame.RowCount); var chisquareStatisticSum = 0.0; if (splittingResults.IsSplitNumeric) { return true; } var degreesOfFreedom = (uniqueDependentValuesCounts.Keys.Count - 1) + (splittingResults.SplittedDataSets.Count - 1); foreach (var splittingResult in splittingResults.SplittedDataSets) { var splitSize = splittingResult.SplittedDataFrame.RowCount; var actualDependentFeatureValues = splittingResult.SplittedDataFrame.GetColumnVector(dependentFeatureName) .Values.GroupBy(elem => elem) .ToDictionary(grp => grp.Key, grp => grp.Count()); foreach (var uniqueDependentValueCount in uniqueDependentValuesCounts) { var expectedCount = uniqueDependentValueCount.Value * splitSize; var actualCount = 0; if (actualDependentFeatureValues.ContainsKey(uniqueDependentValueCount.Key)) { actualCount = actualDependentFeatureValues[uniqueDependentValueCount.Key]; } var actualChisquareValue = Math.Pow(actualCount - expectedCount, 2) / expectedCount; chisquareStatisticSum += actualChisquareValue; } } if (ChiSquared.IsValidParameterSet(degreesOfFreedom)) { var statisticValue = 1 - ChiSquared.CDF(degreesOfFreedom, chisquareStatisticSum); if (statisticValue < significanceLevel) { return true; } } return false; }
public ISplittingResult SelectBestSplit( IDataFrame baseData, string dependentFeatureName, ISplitQualityChecker splitQualityChecker, IAlredyUsedAttributesInfo alreadyUsedAttributesInfo) { ISplittingResult bestSplit = null; double bestSplitQuality = float.NegativeInfinity; double initialEntropy = splitQualityChecker.GetInitialEntropy(baseData, dependentFeatureName); foreach (var attributeToSplit in baseData.ColumnNames.Except(new[] { dependentFeatureName })) { if (baseData.GetColumnType(attributeToSplit).TypeIsNumeric()) { // TODO: add checking for the already used attribtues var bestNumericSplitPointAndQuality = BinaryNumericBestSplitingPointSelector.FindBestSplitPoint( baseData, dependentFeatureName, attributeToSplit, splitQualityChecker, BinaryNumericDataSplitter, initialEntropy); if (bestNumericSplitPointAndQuality.Item2 > bestSplitQuality) { bestSplitQuality = bestNumericSplitPointAndQuality.Item2; bestSplit = bestNumericSplitPointAndQuality.Item1; } } else { var bestSplitForAttribute = EvaluateCategoricalSplit( baseData, dependentFeatureName, attributeToSplit, bestSplitQuality, initialEntropy, splitQualityChecker, alreadyUsedAttributesInfo); if (bestSplitForAttribute.Item3 > bestSplitQuality) { bestSplit = BuildBestSplitObject(bestSplitForAttribute.Item2, bestSplitForAttribute.Item1); bestSplitQuality = bestSplitForAttribute.Item3; } } } return bestSplit; }
public Tuple<ISplittingResult, double> FindBestSplitPoint( IDataFrame baseData, string dependentFeatureName, string numericFeatureToProcess, ISplitQualityChecker splitQualityChecker, IBinaryNumericDataSplitter binaryNumericDataSplitter, double initialEntropy) { return FindBestSplitPoint( baseData, dependentFeatureName, numericFeatureToProcess, splitQualityChecker as ICategoricalSplitQualityChecker, binaryNumericDataSplitter, initialEntropy); }
protected override Tuple<IList<ISplittedData>, ISplittingParams, double> EvaluateCategoricalSplit( IDataFrame dataToSplit, string dependentFeatureName, string splittingFeatureName, double bestSplitQualitySoFar, double initialEntropy, ISplitQualityChecker splitQualityChecker, IAlredyUsedAttributesInfo alredyUsedAttributesInfo) { var totalRowsCount = dataToSplit.RowCount; var uniqueFeatureValues = dataToSplit.GetColumnVector(splittingFeatureName).Distinct(); double locallyBestSplitQuality = double.NegativeInfinity; IBinarySplittingParams localBestSplitParams = null; IList<ISplittedData> locallyBestSplitData = null; foreach (var featureValue in uniqueFeatureValues) { if (!alredyUsedAttributesInfo.WasAttributeAlreadyUsedWithValue(splittingFeatureName, featureValue)) { var binarySplitParams = new BinarySplittingParams(splittingFeatureName, featureValue, dependentFeatureName); var splittedData = CategoricalDataSplitter.SplitData(dataToSplit, binarySplitParams); if (splittedData.Count == 1) { return new Tuple<IList<ISplittedData>, ISplittingParams, double>( new List<ISplittedData>(), binarySplitParams, double.NegativeInfinity); } var splitQuality = splitQualityChecker.CalculateSplitQuality( initialEntropy, totalRowsCount, splittedData, dependentFeatureName); if (splitQuality > locallyBestSplitQuality) { locallyBestSplitQuality = splitQuality; locallyBestSplitData = splittedData; localBestSplitParams = binarySplitParams; } } } return new Tuple<IList<ISplittedData>, ISplittingParams, double>( locallyBestSplitData, localBestSplitParams, locallyBestSplitQuality); }
public IDecisionTreeLeaf BuildLeaf(IDataFrame finalData, string dependentFeatureName) { var vectorY = finalData.GetNumericColumnVector(dependentFeatureName); var featureNames = finalData.ColumnNames.Except(new[] { dependentFeatureName }).ToList(); var subset = finalData.GetSubsetByColumns(featureNames); var matrixX = finalData.GetSubsetByColumns(featureNames).GetAsMatrixWithIntercept(); Vector<double> fittedWeights = null; try { fittedWeights = MultipleRegression.DirectMethod(matrixX, vectorY); } catch (Exception) { fittedWeights = regressionModelBuilder.BuildModel(matrixX, vectorY, regressionParams).Weights; } return new RegressionAndModelLeaf(dependentFeatureName, fittedWeights, vectorY.Mean()); }
public IList<double> Predict(IDataFrame queryDataFrame, IPredictionModel model, string dependentFeatureName) { if (!(model is ILinearRegressionModel)) { throw new ArgumentException("Invalid model passed to Linear Regression predictor!"); } var linearRegressionModel = model as ILinearRegressionModel; var xMatrix = queryDataFrame.GetSubsetByColumns( queryDataFrame.ColumnNames.Except(new[] { dependentFeatureName }).ToList()) .GetAsMatrixWithIntercept(); var results = new List<double>(); for (int rowIdx = 0; rowIdx < xMatrix.RowCount; rowIdx++) { var queryRow = xMatrix.Row(rowIdx); var result = linearRegressionModel.Weights.DotProduct(queryRow); results.Add(result); } return results; }
public IList<ISplittedData> SplitData(IDataFrame dataToSplit, ISplittingParams splttingParams) { var splitFeature = splttingParams.SplitOnFeature; var totalRowsCount = dataToSplit.RowCount; var uniqueValues = dataToSplit.GetColumnVector(splitFeature).Distinct(); var splittedData = new List<ISplittedData>(); //TODO: AAA emarassingly parallel - test it for performance foreach (var uniqueValue in uniqueValues) { var query = BuildQuery(splitFeature, uniqueValue); var splitResult = dataToSplit.GetSubsetByQuery(query); var subsetCount = splitResult.RowCount; var link = new DecisionLink( CalcInstancesPercentage(totalRowsCount, subsetCount), subsetCount, uniqueValue); splittedData.Add(new SplittedData(link, splitResult)); } return splittedData; }
/// <summary> /// 适应模版宽度,等比例缩放图像,高度空白区域自动填充。 /// </summary> /// <param name="temp">专题模版</param> /// <param name="width">原图像宽度</param> /// <param name="height">原图像高度</param> protected void FitTemplateWidth(ILayout layout, int width, int height) { IElement[] dfs = layout.QueryElements((e) => { return(e is IDataFrame); }); IDataFrame df = (dfs[0] as IDataFrame); if (df.Size.Width == width && df.Size.Height == height) { return; } float dfNewW = df.Size.Width; float sc = width / dfNewW; float dfNewH = height / sc; float yOffset = dfNewH - df.Size.Height; df.IsLocked = false; df.ApplySize(0f, yOffset); df.IsLocked = true; layout.Size = new System.Drawing.SizeF(layout.Size.Width, layout.Size.Height + yOffset); List <IElement> eles = layout.Elements; for (int i = 0; i < eles.Count; i++) { if (eles[i].Name == "标题" || eles[i].Name.Contains("Time") || eles[i].Name.Contains("Date") || eles[i].Name.Contains("Day")) { continue; } if (eles[i] is IBorder || eles[i] is IDataFrame) { continue; } if (eles[i] is ISizableElement) { (eles[i] as ISizableElement).ApplyLocation(0f, yOffset); } } }
private void ChangeTemplateSize(ILayout layout, int width, int height) { IElement[] dfs = layout.QueryElements((e) => { return(e is IDataFrame); }); if (dfs == null || dfs.Length == 0) { return; } IDataFrame df = (dfs[0] as IDataFrame); if (df.Size.Width == width && df.Size.Height == height) { return; } float yOffset = height - df.Size.Height; float xOffset = width - df.Size.Width; df.IsLocked = false; df.ApplySize(xOffset, yOffset); df.IsLocked = true; layout.Size = new System.Drawing.SizeF(width, height); List <IElement> eles = layout.Elements; for (int i = 0; i < eles.Count; i++) { if (eles[i].Name == "标题" || eles[i].Name.Contains("Time") || eles[i].Name.Contains("Date")) { continue; } if (eles[i] is IBorder || eles[i] is IDataFrame) { continue; } if (eles[i] is ISizableElement) { (eles[i] as ISizableElement).ApplyLocation(xOffset, yOffset); } } }
private void GetCanvasByLayoutDataFrame() { ILayoutViewer view = _smartSession.SmartWindowManager.ActiveViewer as ILayoutViewer; if (view == null) { return; } _host = view.LayoutHost; if (_host == null) { return; } IDataFrame dataFrame = _host.ActiveDataFrame; if (dataFrame == null) { return; } _canvas = (dataFrame.Provider as IDataFrameDataProvider).Canvas; }
private ICanvas GetCanvasByLayoutDataFrame(ref ILayoutHost host) { ILayoutViewer view = _session.SmartWindowManager.ActiveViewer as ILayoutViewer; if (view == null) { return(null); } host = view.LayoutHost; if (host == null) { return(null); } IDataFrame dataFrame = host.ActiveDataFrame; if (dataFrame == null) { return(null); } return((dataFrame.Provider as IDataFrameDataProvider).Canvas); }
public IList <ISplittedData> SplitData(IDataFrame dataToSplit, ISplittingParams splttingParams) { var splitFeature = splttingParams.SplitOnFeature; var totalRowsCount = dataToSplit.RowCount; var uniqueValues = dataToSplit.GetColumnVector(splitFeature).Distinct(); var splittedData = new List <ISplittedData>(); //TODO: AAA emarassingly parallel - test it for performance foreach (var uniqueValue in uniqueValues) { var query = BuildQuery(splitFeature, uniqueValue); var splitResult = dataToSplit.GetSubsetByQuery(query); var subsetCount = splitResult.RowCount; var link = new DecisionLink( CalcInstancesPercentage(totalRowsCount, subsetCount), subsetCount, uniqueValue); splittedData.Add(new SplittedData(link, splitResult)); } return(splittedData); }
public IPredictionModel BuildModel( IDataFrame dataFrame, string dependentFeatureName, IModelBuilderParams additionalParams) { if (!(additionalParams is IDecisionTreeModelBuilderParams)) { throw new ArgumentException("Invalid params passed for Decision Tree Model Builder!"); } if (ShouldStopRecusrsiveBuilding(dataFrame, dependentFeatureName)) { return BuildLeaf(dataFrame, dependentFeatureName); } var decisionTreeParams = (IDecisionTreeModelBuilderParams)additionalParams; var useParallelProcessing = decisionTreeParams.ProcessSubtreesCreationInParallel; var alreadyUsedAttributesInfo = new AlreadyUsedAttributesInfo(); //TODO: reduce the number of parameters - maybe some nicer DTO? var node = this.BuildDecisionNode(dataFrame, dependentFeatureName, decisionTreeParams, alreadyUsedAttributesInfo, 0, useParallelProcessing); return node; }
public override void Execute() { ILayoutViewer view = _smartSession.SmartWindowManager.ActiveViewer as ILayoutViewer; if (view == null) { return; } if (view.LayoutHost == null) { return; } ILayoutHost host = view.LayoutHost; IDataFrame frm = host.ActiveDataFrame; if (frm != null) { //(frm.Provider as IDataFrameDataProvider).Canvas.Refresh(enumRefreshType.All); host.Render(true); } }
private IDataFrame GetDataFrame(IDataFrame df) { if (df == null) { return(null); } if (df.Provider != null) { ICanvas canvas = (df.Provider as IDataFrameDataProvider).Canvas; if (canvas == null) { return(null); } if (canvas.LayerContainer.VectorHost == null) { IVectorHostLayer vectorH = new VectorHostLayer(null); canvas.LayerContainer.Layers.Add(vectorH as ILayer); } } return(df); }
public IList <IDataQualityReport <TPredictionResult> > CrossValidate( IPredictionModelBuilder modelBuilder, IModelBuilderParams modelBuilderParams, IPredictor <TPredictionResult> predictor, IDataQualityMeasure <TPredictionResult> qualityMeasure, IDataFrame dataFrame, string dependentFeatureName, double percetnagOfTrainData, int folds) { var trainingDataCount = (int)Math.Round(percetnagOfTrainData * dataFrame.RowCount); var testDataCount = dataFrame.RowCount - trainingDataCount; var shuffledAllIndices = dataFrame.RowIndices.Shuffle(_randomizer); var maxWindowsCount = dataFrame.RowCount / testDataCount; var iterationAccuracies = new List <IDataQualityReport <TPredictionResult> >(); var currentWindowNo = 0; for (var i = 0; i < folds; i++) { if (currentWindowNo == maxWindowsCount) { currentWindowNo = 0; shuffledAllIndices = shuffledAllIndices.Shuffle(); } var offset = currentWindowNo * testDataCount; var trainingIndices = shuffledAllIndices.Skip(offset).Take(trainingDataCount).ToList(); var trainingData = dataFrame.GetSubsetByRows(trainingIndices); var testIndices = shuffledAllIndices.Except(trainingIndices).ToList(); var testData = dataFrame.GetSubsetByRows(testIndices); IPredictionModel model = modelBuilder.BuildModel(trainingData, dependentFeatureName, modelBuilderParams); IList <TPredictionResult> predictions = predictor.Predict(testData, model, dependentFeatureName); IList <TPredictionResult> expected = testData.GetColumnVector <TPredictionResult>(dependentFeatureName); IDataQualityReport <TPredictionResult> qualityReport = qualityMeasure.GetReport(expected, predictions); iterationAccuracies.Add(qualityReport); currentWindowNo++; } return(iterationAccuracies); }
private void GetLayerItemLayouts(ILayerItemGroup g, ILayerObjectContainer layerObjContainer) { ILayerObjectBase[] layers = layerObjContainer.LayerObjects.ToArray(); foreach (ILayerObjectBase obj in layers) { if (obj is ILayerObject) { ILayerObject layerObj = obj as ILayerObject; ILayerItem it = new LayerObjectItem(layerObj); g.Items.Add(it); } else { LayerItemGroup group = new LayerItemGroup(obj.Text ?? string.Empty, obj.Text ?? string.Empty); IDataFrame df = layerObjContainer as IDataFrame; if (df != null) { IDataFrameDataProvider prd = df.Provider as IDataFrameDataProvider; if (prd != null) { ICanvas canvas = prd.Canvas; if (canvas != null) { GeoDo.RSS.Core.DrawEngine.ILayerContainer lc = canvas.LayerContainer as GeoDo.RSS.Core.DrawEngine.ILayerContainer; if (lc != null) { IVectorHostLayer hostLayer = canvas.LayerContainer.VectorHost; if (hostLayer != null) { group.Tag = hostLayer.Map; } } } } } g.Items.Add(group); GetLayerItemLayouts(group, (obj as ILayerObjecGroup).Children.ToArray()); } } }
public void Sort_Index_Test() { IDataFrame df = _dataFrame; List <int> indexs = new List <int>(); int r = new Random().Next(0, df.Columns.Size / 2); for (int i = 0; i < df.Columns.Size; i += r) { indexs.Add(i); } //var str = ShowDataFrameValues(_dataFrame); var result = df.sort_values(indexs.ToArray()); //var str2 = ShowDataFrameValues(result); int index = indexs[0]; var col = result[index]; for (int i = 0; i < result.Index.Size - 1; i++) { Assert.True(Convert.ToDecimal(col[i]) <= Convert.ToDecimal(col[i + 1])); } }
public void WriteCsvFormated_ToFile_Test() { var filepath = "write_quoted_test.csv"; var array = np.arange(0, 50, 0.5).reshape(20, 5); var columnNames = new string[] { "first", "second", "third", "fourth", "fifth" }; var floatFormat = "E03"; var pd = new Pandas(); IDataFrame df1 = pd.DataFrame(array, null, columnNames, typeof(object)); df1.to_csv(filepath, float_format: floatFormat); using (var fr = File.OpenText(filepath)) { Assert.Equal(string.Join(',', columnNames), fr.ReadLine()); for (var i = 0; i < array.shape[0]; i++) { var formattedData = array[i].Data <double>().Select( x => x.ToString(floatFormat)); Assert.Equal(string.Join(",", formattedData), fr.ReadLine()); } } }
private ICanvas GetCanvasByTemplate(ILayoutTemplate temp) { if (temp == null) { return(null); } IDataFrame df = FindDataFrameByTemplate(ref temp); if (df == null) { return(null); } if (df.Provider == null) { return(null); } if (!(df.Provider is IDataFrameDataProvider)) { return(null); } return((df.Provider as IDataFrameDataProvider).Canvas); }
public void AddVectorDataToLayoutViewer(string fname, bool isNeedCheckNormalImage, params object[] options) { ILayoutViewer v = _session.SmartWindowManager.ActiveViewer as ILayoutViewer; if (v == null) { return; } IDataFrame df = v.LayoutHost.ActiveDataFrame; if (df == null) { return; } IDataFrameDataProvider provider = df.Provider as IDataFrameDataProvider; if (provider == null) { return; } ICanvas c = provider.Canvas; if (c == null) { return; } IVectorHostLayer host = c.LayerContainer.VectorHost as IVectorHostLayer; if (host == null) { return; } AddToCanvas(c, isNeedCheckNormalImage, host, fname); // c.Refresh(enumRefreshType.All); // (v.LayoutHost).SetActiveDataFrame2CurrentTool(); (v.LayoutHost).Render(true); }
private void button26_Click(object sender, EventArgs e) { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "等值线(*.xml)|*.xml"; if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK) { IContourLayer lyr = ContourLayer.FromXml(dlg.FileName, true); if (lyr != null) { IDataFrame df = _host.ActiveDataFrame; if (df == null) { return; } ICanvas canvas = (df.Provider as IDataFrameDataProvider).Canvas; canvas.LayerContainer.Layers.Add(lyr); canvas.Refresh(enumRefreshType.All); } } } }
public IPredictionModel BuildModel( IDataFrame dataFrame, string dependentFeatureName, IModelBuilderParams additionalParams) { if (!(additionalParams is IDecisionTreeModelBuilderParams)) { throw new ArgumentException("Invalid params passed for Decision Tree Model Builder!"); } if (ShouldStopRecusrsiveBuilding(dataFrame, dependentFeatureName)) { return(BuildLeaf(dataFrame, dependentFeatureName)); } var decisionTreeParams = (IDecisionTreeModelBuilderParams)additionalParams; var useParallelProcessing = decisionTreeParams.ProcessSubtreesCreationInParallel; var alreadyUsedAttributesInfo = new AlreadyUsedAttributesInfo(); //TODO: reduce the number of parameters - maybe some nicer DTO? var node = this.BuildDecisionNode(dataFrame, dependentFeatureName, decisionTreeParams, alreadyUsedAttributesInfo, 0, useParallelProcessing); return(node); }
private ILayer InitDataFrame(string gxfile, IElement ele, bool isLoadGeoGridLayer) { IDataFrame df = ele as IDataFrame; df.BorderColor = (ele as IDataFrame).BorderColor; df.BorderWidth = (ele as IDataFrame).BorderWidth; df.Location = (ele as IDataFrame).Location; df.Size = (ele as IDataFrame).Size; df.Angle = (ele as IDataFrame).Angle; df.Update(this); IDataFrameDataProvider provider = df.Provider as IDataFrameDataProvider; ILayer gridLayer = null; if (df.GeoGridXml != null) { gridLayer = LoadGeoGridLayerExecutor(df.GeoGridXml); } if (provider != null) { ICanvas c = provider.Canvas; if (c != null) { if (c.CanvasSetting != null) { if (c.CanvasSetting.RenderSetting != null) { c.CanvasSetting.RenderSetting.BackColor = Color.White; } } if (df.Data != null && LoadDataFrameExecutor != null) { LoadDataFrameExecutor(gxfile, this, df, df.Data as XElement); } } } return(gridLayer); }
// NOTE: This function is called at runtime and edit time. Keep that in mind when setting the values of properties. public override void ProcessFrame(Playable playable, FrameData info, object playerData) { DataListener trackBinding = playerData as DataListener; if (trackBinding == null) { Debug.Log("Track without Trackbinding"); return; } int inputCount = playable.GetInputCount(); for (int i = 0; i < inputCount; i++) { float inputWeight = playable.GetInputWeight(i); ScriptPlayable <RecordingBehaviour> inputPlayable = (ScriptPlayable <RecordingBehaviour>)playable.GetInput(i); RecordingBehaviour input = inputPlayable.GetBehaviour(); // Use the above variables to process each frame of this playable. if (inputWeight > 0 && input.recording != null) { float timeS = (float)inputPlayable.GetTime(); float duration = input.recording.duration; if (duration > 0) { timeS = timeS % duration; //loop } IDataFrame frame = input.recording.GetDataFrame(timeS); if (frame != null) { trackBinding.ProcessData(frame); } } } }
/// <summary> /// Raises the <see cref="FrameParserBase{TypeIndentifier}.ReceivedDataFrame"/> event. /// </summary> /// <param name="frame"><see cref="IDataFrame"/> to send to <see cref="FrameParserBase{TypeIndentifier}.ReceivedDataFrame"/> event.</param> protected override void OnReceivedDataFrame(IDataFrame frame) { // We override this method so we can detect and respond to a configuration change notification base.OnReceivedDataFrame(frame); bool configurationChangeDetected = false; DataCellCollection dataCells = frame.Cells as DataCellCollection; if (dataCells != null) { // Check for a configuration change notification from any data cell for (int x = 0; x < dataCells.Count; x++) { // Configuration change is only relevant if raw status flags <> FF (status undefined) if (dataCells[x].ConfigurationChangeDetected && !dataCells[x].DeviceError && ((DataCellBase)dataCells[x]).StatusFlags != ushort.MaxValue) { configurationChangeDetected = true; // Configuration change detection flag should terminate after one minute, but // we only want to send a single notification if (!m_configurationChangeHandled) { m_configurationChangeHandled = true; base.OnConfigurationChanged(); } break; } } } if (!configurationChangeDetected) { m_configurationChangeHandled = false; } }
private static IDataFrame CreateDataFrame(IDataFrame df, List <int> indexs) { var value = df.Values.Array; int colSize = df.Columns.Size; int rowSize = df.Index.Size; var cols = df.Columns.Values.Array; var rows = df.Index.Values.Array; var rowArray = Array.CreateInstance(df.Index.DType, rows.Length); int index = 0; foreach (var ind in indexs) { rowArray.SetValue(rows.GetValue(ind), index); index++; } object[] objs = new object[df.Size]; int ins = 0; for (int c = 0; c < colSize; c++) { for (int r = 0; r < rowSize; r++) { objs[ins] = value.GetValue(indexs[r] + c * rowSize); ins++; } } NDArray nDArray = new NDArray(df.DType, new Shape(rowSize, colSize)); nDArray.SetData(objs); var pd = new Pandas(); IDataFrame dataFrame = pd.DataFrame(nDArray, null, null, df.DType); dataFrame.Index.Values.SetData(rowArray); dataFrame.Columns.Values.SetData(cols); return(dataFrame); }
private static ISpatialReference GetSpatialRef(ISmartSession session) { ISmartViewer activeViewer = session.SmartWindowManager.ActiveViewer; if (activeViewer is ICanvasViewer) { return((activeViewer as ICanvasViewer).Canvas.CoordTransform.SpatialRefOfViewer as ISpatialReference); } else if (activeViewer is ILayoutViewer) { IDataFrame df = (activeViewer as ILayoutViewer).LayoutHost.ActiveDataFrame; if (df == null) { return(null); } IDataFrameDataProvider prd = df.Provider as IDataFrameDataProvider; if (prd == null) { return(null); } return(prd.Canvas.CoordTransform.SpatialRefOfViewer as ISpatialReference); } return(null); }
public void SliceLabel_Row_Desc_Test() { IDataFrame df1 = _dataFrame; var sobj1 = df1.loc["row2"]; var sobj2 = df1.loc["row4"]; var dfSl1 = df1[(SliceLabel)"row2:row5:2"]; var obj1 = dfSl1.iloc[0]; var obj2 = dfSl1.iloc[1]; Assert.Equal(sobj1[0], obj1[0]); Assert.Equal(sobj1[1], obj1[1]); Assert.Equal(sobj2[0], obj2[0]); Assert.Equal(sobj2[1], obj2[1]); var dfSl2 = df1[(SliceLabel)"row2:row5:-2"]; sobj1 = df1.loc["row4"]; sobj2 = df1.loc["row2"]; obj1 = dfSl2.iloc[0]; obj2 = dfSl2.iloc[1]; Assert.Equal(sobj1[0], obj1[0]); Assert.Equal(sobj1[1], obj1[1]); Assert.Equal(sobj2[0], obj2[0]); Assert.Equal(sobj2[1], obj2[1]); }
public ICanvas GetCanvas(string fname, params object[] options) { ILayoutViewer v = _session.SmartWindowManager.ActiveViewer as ILayoutViewer; if (v == null) { return(null); } IDataFrame df = v.LayoutHost.ActiveDataFrame; if (df == null) { return(null); } IDataFrameDataProvider provider = df.Provider as IDataFrameDataProvider; if (provider == null) { return(null); } ICanvas c = provider.Canvas; return(c); }
/// <summary> /// Creates a new <see cref="DataCell"/>. /// </summary> /// <param name="parent">The reference to parent <see cref="IDataFrame"/> of this <see cref="DataCell"/>.</param> /// <param name="configurationCell">The <see cref="IConfigurationCell"/> associated with this <see cref="DataCell"/>.</param> public DataCell(IDataFrame parent, IConfigurationCell configurationCell) : base(parent, configurationCell, 0x0000, Common.MaximumPhasorValues, Common.MaximumAnalogValues, Common.MaximumDigitalValues) { }
/// <summary> /// Creates a new <see cref="DataCell"/>. /// </summary> /// <param name="parent">The reference to parent <see cref="IDataFrame"/> of this <see cref="DataCell"/>.</param> /// <param name="configurationCell">The <see cref="IConfigurationCell"/> associated with this <see cref="DataCell"/>.</param> public DataCell(IDataFrame parent, IConfigurationCell configurationCell) : base(parent, configurationCell, (ushort)(StatusFlags.TSOK | StatusFlags.PMDOK), Common.MaximumPhasorValues, Common.MaximumAnalogValues, Common.MaximumDigitalValues) { }
public IList<double> Predict(IDataFrame queryDataFrame, IPredictionModel model, int dependentFeatureIndex) { return Predict(queryDataFrame, model, queryDataFrame.ColumnNames[dependentFeatureIndex]); }
/// <summary> /// Extract frame measurements and add expose them via the <see cref="IInputAdapter.NewMeasurements"/> event. /// </summary> /// <param name="frame">Phasor data frame to extract measurements from.</param> protected void ExtractFrameMeasurements(IDataFrame frame) { const int AngleIndex = (int)CompositePhasorValue.Angle; const int MagnitudeIndex = (int)CompositePhasorValue.Magnitude; const int FrequencyIndex = (int)CompositeFrequencyValue.Frequency; const int DfDtIndex = (int)CompositeFrequencyValue.DfDt; List<IMeasurement> mappedMeasurements = new List<IMeasurement>(m_lastMeasurementMappedCount); List<IMeasurement> deviceMappedMeasurements = new List<IMeasurement>(); DeviceStatisticsHelper<ConfigurationCell> statisticsHelper; ConfigurationCell definedDevice; PhasorValueCollection phasors; AnalogValueCollection analogs; DigitalValueCollection digitals; IMeasurement[] measurements; long timestamp; int x, count; // Adjust time to UTC based on source time zone if (!m_timezone.Equals(TimeZoneInfo.Utc)) frame.Timestamp = TimeZoneInfo.ConvertTimeToUtc(frame.Timestamp, m_timezone); // We also allow "fine tuning" of time for fickle GPS clocks... if (m_timeAdjustmentTicks.Value != 0) frame.Timestamp += m_timeAdjustmentTicks; // Get adjusted timestamp of this frame timestamp = frame.Timestamp; // Track latest reporting time for mapper if (timestamp > m_lastReportTime.Value) m_lastReportTime = timestamp; else m_outOfOrderFrames++; // Track latency statistics against system time - in order for these statistics // to be useful, the local clock must be fairly accurate long latency = frame.CreatedTimestamp.Value - timestamp; // Throw out latencies that exceed one hour as invalid if (Math.Abs(latency) <= Time.SecondsPerHour * Ticks.PerSecond) { if (m_minimumLatency > latency || m_minimumLatency == 0) m_minimumLatency = latency; if (m_maximumLatency < latency || m_maximumLatency == 0) m_maximumLatency = latency; m_totalLatency += latency; m_latencyFrames++; if (m_lifetimeMinimumLatency > latency || m_lifetimeMinimumLatency == 0) m_lifetimeMinimumLatency = latency; if (m_lifetimeMaximumLatency < latency || m_lifetimeMaximumLatency == 0) m_lifetimeMaximumLatency = latency; m_lifetimeTotalLatency += latency; m_lifetimeLatencyFrames++; } // Map quality flags (QF) from device frame, if any MapMeasurementAttributes(mappedMeasurements, m_qualityFlagsMetadata, frame.GetQualityFlagsMeasurement()); // Loop through each parsed device in the data frame foreach (IDataCell parsedDevice in frame.Cells) { try { // Lookup device by its label (if needed), then by its ID code if (((object)m_labelDefinedDevices != null && m_labelDefinedDevices.TryGetValue(parsedDevice.StationName.ToNonNullString(), out statisticsHelper)) || m_definedDevices.TryGetValue(parsedDevice.IDCode, out statisticsHelper)) { definedDevice = statisticsHelper.Device; // Track latest reporting time for this device if (timestamp > definedDevice.LastReportTime.Value) definedDevice.LastReportTime = timestamp; // Track quality statistics for this device definedDevice.TotalFrames++; if (!parsedDevice.DataIsValid) definedDevice.DataQualityErrors++; if (!parsedDevice.SynchronizationIsValid) definedDevice.TimeQualityErrors++; if (parsedDevice.DeviceError) definedDevice.DeviceErrors++; // Map status flags (SF) from device data cell itself MapMeasurementAttributes(mappedMeasurements, definedDevice.GetMetadata(m_definedMeasurements, SignalKind.Status), parsedDevice.GetStatusFlagsMeasurement()); // Map phase angles (PAn) and magnitudes (PMn) phasors = parsedDevice.PhasorValues; count = phasors.Count; for (x = 0; x < count; x++) { // Get composite phasor measurements measurements = phasors[x].Measurements; // Map angle MapMeasurementAttributes(deviceMappedMeasurements, definedDevice.GetMetadata(m_definedMeasurements, SignalKind.Angle, x, count), measurements[AngleIndex]); // Map magnitude MapMeasurementAttributes(deviceMappedMeasurements, definedDevice.GetMetadata(m_definedMeasurements, SignalKind.Magnitude, x, count), measurements[MagnitudeIndex]); } // Map frequency (FQ) and dF/dt (DF) measurements = parsedDevice.FrequencyValue.Measurements; // Map frequency MapMeasurementAttributes(deviceMappedMeasurements, definedDevice.GetMetadata(m_definedMeasurements, SignalKind.Frequency), measurements[FrequencyIndex]); // Map dF/dt MapMeasurementAttributes(deviceMappedMeasurements, definedDevice.GetMetadata(m_definedMeasurements, SignalKind.DfDt), measurements[DfDtIndex]); // Map analog values (AVn) analogs = parsedDevice.AnalogValues; count = analogs.Count; // Map analog values for (x = 0; x < count; x++) MapMeasurementAttributes(deviceMappedMeasurements, definedDevice.GetMetadata(m_definedMeasurements, SignalKind.Analog, x, count), analogs[x].Measurements[0]); // Map digital values (DVn) digitals = parsedDevice.DigitalValues; count = digitals.Count; // Map digital values for (x = 0; x < count; x++) MapMeasurementAttributes(deviceMappedMeasurements, definedDevice.GetMetadata(m_definedMeasurements, SignalKind.Digital, x, count), digitals[x].Measurements[0]); // Track measurement count statistics for this device if (m_countOnlyMappedMeasurements) statisticsHelper.AddToMeasurementsReceived(CountMappedMeasurements(parsedDevice, deviceMappedMeasurements)); else statisticsHelper.AddToMeasurementsReceived(CountParsedMeasurements(parsedDevice)); mappedMeasurements.AddRange(deviceMappedMeasurements); deviceMappedMeasurements.Clear(); } else { // Encountered an undefined device, track frame counts long frameCount; if (m_undefinedDevices.TryGetValue(parsedDevice.StationName, out frameCount)) { frameCount++; m_undefinedDevices[parsedDevice.StationName] = frameCount; } else { m_undefinedDevices.TryAdd(parsedDevice.StationName, 1); OnStatusMessage(MessageLevel.Warning, $"Encountered an undefined device \"{parsedDevice.StationName}\"..."); } } } catch (Exception ex) { OnProcessException(MessageLevel.Warning, new InvalidOperationException($"Exception encountered while mapping \"{Name}\" data frame cell \"{parsedDevice.StationName.ToNonNullString("[undefined]")}\" elements to measurements: {ex.Message}", ex)); } } m_lastMeasurementMappedCount = mappedMeasurements.Count; // Provide real-time measurements where needed OnNewMeasurements(mappedMeasurements); int measurementCount = mappedMeasurements.Count; m_lifetimeMeasurements += measurementCount; UpdateMeasurementsPerSecond(measurementCount); }
/// <summary> /// Creates a new <see cref="DataCell"/>. /// </summary> /// <param name="parent">The reference to parent <see cref="IDataFrame"/> of this <see cref="DataCell"/>.</param> /// <param name="configurationCell">The <see cref="IConfigurationCell"/> associated with this <see cref="DataCell"/>.</param> public DataCell(IDataFrame parent, IConfigurationCell configurationCell) : base(parent, configurationCell, Common.MaximumPhasorValues, Common.MaximumAnalogValues, Common.MaximumDigitalValues) { }
protected override void ApplyAttributesOfDataFrame(IGxdDataFrame gxdDataFrame, IDataFrame dataFrame, ILayout layout) { try { Layout.GxdEnvelope evp = ToPrjEnvelope(_shpEnvelope, gxdDataFrame, dataFrame); if (evp != null) { FitSizeToTemplateWidth(layout, (float)(evp.MaxX - evp.MinX), (float)(evp.MaxY - evp.MinY)); gxdDataFrame.Envelope = evp; } } catch (Exception ex) { Console.WriteLine(ex.Message); } base.ApplyAttributesOfDataFrame(gxdDataFrame, dataFrame, layout); }
public Row(IDataFrame parentDataFrame, IEnumerable<IColumnValue> columns) { this.parentDataFrame = parentDataFrame; this.columns = columns.ToArray(); }
public override IPredictionModel BuildModel(IDataFrame dataFrame, string dependentFeatureName, IModelBuilderParams additionalParams) { ValidateAdditionalParams(additionalParams); return(PerformBackwardsElimination(dataFrame, dependentFeatureName, additionalParams as IKnnAdditionalParams)); }
protected override void ApplyAttributesOfDataFrame(IGxdDataFrame gxdDataFrame, IDataFrame dataFrame, ILayout layout) { string instanceIdentify = _argumentProvider.GetArg("OutFileIdentify") as string; Layout.GxdEnvelope evp = ToPrjEnvelope(_envelope, gxdDataFrame, dataFrame); if (evp != null) { FitSizeToTemplateWidth(layout, (float)(evp.MaxX - evp.MinX), (float)(evp.MaxY - evp.MinY)); gxdDataFrame.Envelope = evp; _envelope = null; } }
protected IBackwardsEliminationKnnModel <TPredictionResult> PerformBackwardsElimination(IDataFrame dataFrame, string dependentFeatureName, IKnnAdditionalParams additionalParams) { Tuple <Matrix <double>, IList <TPredictionResult>, IList <string> > preparedData = PrepareTrainingData(dataFrame, dependentFeatureName); var dataColumnsNames = preparedData.Item3; var trainingData = _dataNormalizer.NormalizeColumns(preparedData.Item1); var expectedValues = preparedData.Item2; // TODO: refactor this - ugly! _knnPredictor.NormalizeNumericValues = false; double baseErrorRate = ProcessDataAndQuantifyErrorRate( dependentFeatureName, trainingData, expectedValues, dataColumnsNames, additionalParams); var actualDataColumnNames = new List <string>(dataColumnsNames); var anyFeatureRemovedInThisIteration = true; var removedFeaturesInfo = new List <IBackwardsEliminationRemovedFeatureData>(); while (anyFeatureRemovedInThisIteration) { anyFeatureRemovedInThisIteration = false; var candidateFeaturesToEliminate = new Dictionary <int, double>(); foreach (var columnIdx in Enumerable.Range(0, actualDataColumnNames.Count)) { var newFeatureNames = new List <string>(actualDataColumnNames); newFeatureNames.RemoveAt(columnIdx); var trainingDataWithoutColumn = trainingData.RemoveColumn(columnIdx); var newDataPredictionError = ProcessDataAndQuantifyErrorRate( dependentFeatureName, trainingDataWithoutColumn, expectedValues, newFeatureNames, additionalParams); if (newDataPredictionError <= baseErrorRate) { var errorGain = baseErrorRate - newDataPredictionError; candidateFeaturesToEliminate.Add(columnIdx, errorGain); } } if (!candidateFeaturesToEliminate.Any()) { break; } var bestFeatureToRemove = candidateFeaturesToEliminate.OrderBy(kvp => kvp.Value).First(); anyFeatureRemovedInThisIteration = true; removedFeaturesInfo.Add(new BackwardsEliminationRemovedFeatureData(bestFeatureToRemove.Value, actualDataColumnNames[bestFeatureToRemove.Key])); actualDataColumnNames.RemoveAt(bestFeatureToRemove.Key); baseErrorRate = bestFeatureToRemove.Value; } return(new BackwardsEliminationKnnModel <TPredictionResult>( preparedData.Item1, expectedValues, dataColumnsNames, additionalParams.KNeighbors, additionalParams.UseWeightedDistances, removedFeaturesInfo)); }
private GxdEnvelope ToPrjEnvelope(GxdEnvelope env, IGxdDataFrame gxdDataFrame, IDataFrame dataFrame) { if (env == null) { return(null); } GeoDo.Project.IProjectionTransform tran = GetProjectionTransform(gxdDataFrame.SpatialRef); if (tran == null) { return(null); } double[] xs = new double[] { env.MinX, env.MaxX }; double[] ys = new double[] { env.MaxY, env.MinY }; try { tran.Transform(xs, ys); return(new Layout.GxdEnvelope(xs[0], xs[1], ys[1], ys[0])); } catch { return(null); } }
private static void ExtractFrameMeasurements(IDataFrame frame) { const int AngleIndex = (int)CompositePhasorValue.Angle; const int MagnitudeIndex = (int)CompositePhasorValue.Magnitude; const int FrequencyIndex = (int)CompositeFrequencyValue.Frequency; const int DfDtIndex = (int)CompositeFrequencyValue.DfDt; List<IMeasurement> mappedMeasurements = new List<IMeasurement>(); ConfigurationCell definedDevice; PhasorValueCollection phasors; AnalogValueCollection analogs; DigitalValueCollection digitals; IMeasurement[] measurements; int x, count; // Loop through each parsed device in the data frame foreach (IDataCell parsedDevice in frame.Cells) { try { // Lookup device by its label (if needed), then by its ID code definedDevice = m_definedDevices.GetOrAdd(parsedDevice.IDCode, id => new ConfigurationCell(id) { StationName = parsedDevice.StationName, IDLabel = parsedDevice.IDLabel.ToNonNullNorWhiteSpace(parsedDevice.StationName), IDCode = parsedDevice.IDCode }); // Map status flags (SF) from device data cell itself (IDataCell implements IMeasurement // and exposes the status flags as its value) MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Status), parsedDevice.GetStatusFlagsMeasurement()); // Map phase angles (PAn) and magnitudes (PMn) phasors = parsedDevice.PhasorValues; count = phasors.Count; for (x = 0; x < count; x++) { // Get composite phasor measurements measurements = phasors[x].Measurements; // Map angle MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Angle, x, count), measurements[AngleIndex]); // Map magnitude MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Magnitude, x, count), measurements[MagnitudeIndex]); } // Map frequency (FQ) and dF/dt (DF) measurements = parsedDevice.FrequencyValue.Measurements; // Map frequency MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Frequency), measurements[FrequencyIndex]); // Map dF/dt MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.DfDt), measurements[DfDtIndex]); // Map analog values (AVn) analogs = parsedDevice.AnalogValues; count = analogs.Count; for (x = 0; x < count; x++) { // Map analog value MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Analog, x, count), analogs[x].Measurements[0]); } // Map digital values (DVn) digitals = parsedDevice.DigitalValues; count = digitals.Count; for (x = 0; x < count; x++) { // Map digital value MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Digital, x, count), digitals[x].Measurements[0]); } } catch (Exception ex) { Console.WriteLine("Exception encountered while mapping \"{0}\" data frame cell \"{1}\" elements to measurements: {2}", frame.IDCode, parsedDevice.StationName.ToNonNullString("[undefined]"), ex.Message); } } concentrator.SortMeasurements(mappedMeasurements); }
private static void ExtractFrameMeasurements(IDataFrame frame) { const int AngleIndex = (int)CompositePhasorValue.Angle; const int MagnitudeIndex = (int)CompositePhasorValue.Magnitude; const int FrequencyIndex = (int)CompositeFrequencyValue.Frequency; const int DfDtIndex = (int)CompositeFrequencyValue.DfDt; List <IMeasurement> mappedMeasurements = new List <IMeasurement>(); ConfigurationCell definedDevice; PhasorValueCollection phasors; AnalogValueCollection analogs; DigitalValueCollection digitals; IMeasurement[] measurements; int x, count; // Loop through each parsed device in the data frame foreach (IDataCell parsedDevice in frame.Cells) { try { // Lookup device by its label (if needed), then by its ID code definedDevice = m_definedDevices.GetOrAdd(parsedDevice.IDCode, id => new ConfigurationCell(id) { StationName = parsedDevice.StationName, IDLabel = parsedDevice.IDLabel.ToNonNullNorWhiteSpace(parsedDevice.StationName), IDCode = parsedDevice.IDCode }); // Map status flags (SF) from device data cell itself (IDataCell implements IMeasurement // and exposes the status flags as its value) MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Status), parsedDevice.GetStatusFlagsMeasurement()); // Map phase angles (PAn) and magnitudes (PMn) phasors = parsedDevice.PhasorValues; count = phasors.Count; for (x = 0; x < count; x++) { // Get composite phasor measurements measurements = phasors[x].Measurements; // Map angle MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Angle, x, count), measurements[AngleIndex]); // Map magnitude MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Magnitude, x, count), measurements[MagnitudeIndex]); } // Map frequency (FQ) and dF/dt (DF) measurements = parsedDevice.FrequencyValue.Measurements; // Map frequency MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Frequency), measurements[FrequencyIndex]); // Map dF/dt MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.DfDt), measurements[DfDtIndex]); // Map analog values (AVn) analogs = parsedDevice.AnalogValues; count = analogs.Count; for (x = 0; x < count; x++) { // Map analog value MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Analog, x, count), analogs[x].Measurements[0]); } // Map digital values (DVn) digitals = parsedDevice.DigitalValues; count = digitals.Count; for (x = 0; x < count; x++) { // Map digital value MapMeasurementAttributes(mappedMeasurements, definedDevice.GetSignalReference(SignalKind.Digital, x, count), digitals[x].Measurements[0]); } } catch (Exception ex) { Console.WriteLine("Exception encountered while mapping \"{0}\" data frame cell \"{1}\" elements to measurements: {2}", frame.IDCode, parsedDevice.StationName.ToNonNullString("[undefined]"), ex.Message); } } concentrator.SortMeasurements(mappedMeasurements); }
/// <summary> /// Creates a new <see cref="DataCellBase"/> from specified parameters. /// </summary> /// <param name="parent">The reference to parent <see cref="IDataFrame"/> of this <see cref="DataCellBase"/>.</param> /// <param name="configurationCell">The <see cref="IConfigurationCell"/> associated with this <see cref="DataCellBase"/>.</param> /// <param name="statusFlags">The default status flags to apply to this <see cref="DataCellBase"/>.</param> /// <param name="maximumPhasors">Sets the maximum number of phasors for the <see cref="PhasorValues"/> collection.</param> /// <param name="maximumAnalogs">Sets the maximum number of phasors for the <see cref="AnalogValues"/> collection.</param> /// <param name="maximumDigitals">Sets the maximum number of phasors for the <see cref="DigitalValues"/> collection.</param> protected DataCellBase(IDataFrame parent, IConfigurationCell configurationCell, ushort statusFlags, int maximumPhasors, int maximumAnalogs, int maximumDigitals) : base(parent, 0) { m_configurationCell = configurationCell; m_statusFlags = statusFlags; m_phasorValues = new PhasorValueCollection(maximumPhasors); m_analogValues = new AnalogValueCollection(maximumAnalogs); m_digitalValues = new DigitalValueCollection(maximumDigitals); }