public static extern bool CvDTreeTrain(
IntPtr model,
IntPtr trainData,
MlEnum.DataLayoutType tflag,
IntPtr responses,
IntPtr varIdx,
IntPtr sampleIdx,
IntPtr varType,
IntPtr missingMask,
ref MCvDTreeParams param);
public static extern bool CvDTreeTrain(
IntPtr model,
IntPtr trainData,
MlEnum.DATA_LAYOUT_TYPE tflag,
IntPtr responses,
IntPtr varIdx,
IntPtr sampleIdx,
IntPtr varType,
IntPtr missingMask,
MCvDTreeParams param);
/// <summary>
/// Train the decision tree using the specific traning data
/// </summary>
/// <param name="trainData">The training data. A 32-bit floating-point, single-channel matrix, one vector per row</param>
/// <param name="tflag">data layout type</param>
/// <param name="responses">A floating-point matrix of the corresponding output vectors, one vector per row. </param>
/// <param name="varType">The types of input variables</param>
/// <param name="missingMask">Can be null if not needed. When specified, it is an 8-bit matrix of the same size as <paramref name="trainData"/>, is used to mark the missed values (non-zero elements of the mask)</param>
/// <param name="param">The parameters for training the decision tree</param>
/// <returns></returns>
public bool Train(
Matrix <float> trainData,
MlEnum.DATA_LAYOUT_TYPE tflag,
Matrix <float> responses,
Matrix <Byte> varType,
Matrix <Byte> missingMask,
MCvDTreeParams param)
{
return(MlInvoke.CvDTreeTrain(
_ptr,
trainData.Ptr,
tflag,
responses.Ptr,
IntPtr.Zero,
IntPtr.Zero,
varType == null ? IntPtr.Zero : varType.Ptr,
missingMask == null ? IntPtr.Zero : missingMask.Ptr,
param));
}
/// <summary>
/// Train the decision tree using the specific traning data
/// </summary>
/// <param name="trainData">The training data. A 32-bit floating-point, single-channel matrix, one vector per row</param>
/// <param name="tflag">data layout type</param>
/// <param name="responses">A floating-point matrix of the corresponding output vectors, one vector per row. </param>
/// <param name="varMask">Can be null if not needed. When specified, it is a mask that identifies variables (features) of interest. It must be a Matrix>Byte< of n x 1 where n is the number of rows in <paramref name="trainData"/></param>
/// <param name="sampleMask">Can be null if not needed. When specified, it is a mask identifies samples of interest. It must be a Matrix>Byte< of nx1, where n is the number of rows in <paramref name="trainData"/></param>
/// <param name="varType">The types of input variables</param>
/// <param name="missingMask">Can be null if not needed. When specified, it is an 8-bit matrix of the same size as <paramref name="trainData"/>, is used to mark the missed values (non-zero elements of the mask)</param>
/// <param name="param">The parameters for training the decision tree</param>
/// <returns></returns>
public bool Train(
Matrix <float> trainData,
MlEnum.DataLayoutType tflag,
Matrix <float> responses,
Matrix <Byte> varMask,
Matrix <Byte> sampleMask,
Matrix <Byte> varType,
Matrix <Byte> missingMask,
MCvDTreeParams param)
{
return(MlInvoke.CvDTreeTrain(
_ptr,
trainData.Ptr,
tflag,
responses.Ptr,
varMask == null ? IntPtr.Zero : varMask.Ptr,
sampleMask == null ? IntPtr.Zero : sampleMask.Ptr,
varType == null ? IntPtr.Zero : varType.Ptr,
missingMask == null ? IntPtr.Zero : missingMask.Ptr,
ref param));
}
public void TestDTreesMushroom()
{
Matrix <float> data, response;
ReadMushroomData(out data, out response);
//Use the first 80% of data as training sample
int trainingSampleCount = (int)(data.Rows * 0.8);
Matrix <Byte> varType = new Matrix <byte>(data.Cols + 1, 1);
varType.SetValue((byte)MlEnum.VarType.Categorical); //the data is categorical
Matrix <byte> sampleIdx = new Matrix <byte>(data.Rows, 1);
using (Matrix <byte> sampleRows = sampleIdx.GetRows(0, trainingSampleCount, 1))
sampleRows.SetValue(255);
float[] priors = new float[] { 1, 0.5f };
GCHandle priorsHandle = GCHandle.Alloc(priors, GCHandleType.Pinned);
MCvDTreeParams param = new MCvDTreeParams();
param.maxDepth = 8;
param.minSampleCount = 10;
param.regressionAccuracy = 0;
param.useSurrogates = true;
param.maxCategories = 15;
param.cvFolds = 10;
param.use1seRule = true;
param.truncatePrunedTree = true;
param.priors = priorsHandle.AddrOfPinnedObject();
using (DTree dtree = new DTree())
{
bool success = dtree.Train(
data,
Emgu.CV.ML.MlEnum.DataLayoutType.RowSample,
response,
null,
sampleIdx,
varType,
null,
param);
if (!success)
{
return;
}
double trainDataCorrectRatio = 0;
double testDataCorrectRatio = 0;
for (int i = 0; i < data.Rows; i++)
{
using (Matrix <float> sample = data.GetRow(i))
{
double r = dtree.Predict(sample, null, false).value;
r = Math.Abs(r - response[i, 0]);
if (r < 1.0e-5)
{
if (i < trainingSampleCount)
{
trainDataCorrectRatio++;
}
else
{
testDataCorrectRatio++;
}
}
}
}
trainDataCorrectRatio /= trainingSampleCount;
testDataCorrectRatio /= (data.Rows - trainingSampleCount);
EmguAssert.WriteLine(String.Format("Prediction accuracy for training data :{0}%", trainDataCorrectRatio * 100));
EmguAssert.WriteLine(String.Format("Prediction accuracy for test data :{0}%", testDataCorrectRatio * 100));
}
priorsHandle.Free();
}
private void button2_Click_1(object sender, EventArgs e)
{
watch = Stopwatch.StartNew();
makeDataSet();
watch.Stop();
txtFeatureTime.Text = "" + watch.ElapsedMilliseconds;
progressBar1.Value = 100;
int trainingSampleCount = (int)(trainCount * 0.75);
int testSampleCount = (int)(trainCount * 0.25);
watch = Stopwatch.StartNew();
if (chkDtree.Checked)
{
Matrix <Byte> varType = new Matrix <byte>(data.Cols + 1, 1);
varType.SetValue((byte)VAR_TYPE.NUMERICAL);
Matrix <byte> sampleIdx = new Matrix <byte>(data.Rows, 1);
using (Matrix <byte> sampleRows = sampleIdx.GetRows(0, trainingSampleCount, 1))
sampleRows.SetValue(255);
IntPtr priors = new IntPtr();
MCvDTreeParams param = new MCvDTreeParams();
param.maxDepth = 8;
param.minSampleCount = 10;
param.regressionAccuracy = 0;
param.useSurrogates = true;
param.maxCategories = 15;
param.cvFolds = 2;
param.use1seRule = true;
param.truncatePrunedTree = true;
param.priors = priors;
bool success = dtree.Train(
data,
Emgu.CV.ML.MlEnum.DATA_LAYOUT_TYPE.ROW_SAMPLE,
response,
null,
null,
varType,
null,
param);
if (!success)
{
return;
}
}
else
{
SVMParams param = new SVMParams();
param.SVMType = SVM_TYPE.C_SVC;
param.TermCrit = new MCvTermCriteria(1000);
param.C = 4;
svm.Train(data, response, null, null, param);
}
watch.Stop();
txtLearnTime.Text = "" + watch.ElapsedMilliseconds;
double trainDataCorrectRatio = 0;
double testDataCorrectRatio = 0;
Matrix <float> output = new Matrix <float>(1, featureCount);
for (int i = 0; i < data.Rows; i++)
{
using (Matrix <float> sample = data.GetRow(i))
{
double r;
if (chkDtree.Checked)
{
r = dtree.Predict(sample, null, true).value;
}
else
{
r = svm.Predict(sample);
}
r = Math.Abs(Math.Round(r) - response[i, 0]);
if (r < 1.0e-6)
{
if (i >= 0 && i < 3 * trainCount / 16)
{
trainDataCorrectRatio++;
}
else if (i >= 3 * trainCount / 16 && i < trainCount / 4)
{
testDataCorrectRatio++;
}
else if (i >= trainCount / 4 && i < 7 * trainCount / 16)
{
trainDataCorrectRatio++;
}
else if (i >= 7 * trainCount / 16 && i < trainCount / 2)
{
testDataCorrectRatio++;
}
else if (i >= trainCount / 2 && i < 11 * trainCount / 16)
{
trainDataCorrectRatio++;
}
else if (i >= 11 * trainCount / 16 && i < 3 * trainCount / 4)
{
testDataCorrectRatio++;
}
else if (i >= 3 * trainCount / 4 && i < 15 * trainCount / 16)
{
trainDataCorrectRatio++;
}
else if (i >= 15 * trainCount / 16 && i < trainCount)
{
testDataCorrectRatio++;
}
}
}
}
trainDataCorrectRatio /= (trainCount * .75);
testDataCorrectRatio /= (trainCount * .25);
txtTestRate.Text = (Math.Round(testDataCorrectRatio, 4) * 100).ToString();
txtTrainRate.Text = (Math.Round(trainDataCorrectRatio, 4) * 100).ToString();
}
