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);
}
