TimeSeriesClassificationData TimeSeriesClassificationData::getTrainingFoldData(const UINT foldIndex) const {
TimeSeriesClassificationData trainingData;
if( !crossValidationSetup ){
errorLog << "getTrainingFoldData(UINT foldIndex) - Cross Validation has not been setup! You need to call the spiltDataIntoKFolds(UINT K,bool useStratifiedSampling) function first before calling this function!" << std::endl;
return trainingData;
}
if( foldIndex >= kFoldValue ) return trainingData;
trainingData.setNumDimensions( numDimensions );
//Add the data to the training set, this will consist of all the data that is NOT in the foldIndex
UINT index = 0;
for(UINT k=0; k<kFoldValue; k++){
if( k != foldIndex ){
for(UINT i=0; i<crossValidationIndexs[k].size(); i++){
index = crossValidationIndexs[k][i];
trainingData.addSample( data[ index ].getClassLabel(), data[ index ].getData() );
}
}
}
return trainingData;
}
TimeSeriesClassificationData TimeSeriesClassificationDataStream::getTimeSeriesClassificationData( const bool includeNullGestures ) const {
TimeSeriesClassificationData tsData;
tsData.setNumDimensions( getNumDimensions() );
tsData.setAllowNullGestureClass( includeNullGestures );
bool addSample = false;
const UINT numTimeseries = (UINT)timeSeriesPositionTracker.size();
for(UINT i=0; i<numTimeseries; i++){
addSample = includeNullGestures ? true : timeSeriesPositionTracker[i].getClassLabel() != GRT_DEFAULT_NULL_CLASS_LABEL;
if( addSample ){
tsData.addSample(timeSeriesPositionTracker[i].getClassLabel(), getTimeSeriesData( timeSeriesPositionTracker[i] ) );
}
}
return tsData;
}
TimeSeriesClassificationData TimeSeriesClassificationData::getTestFoldData(const UINT foldIndex) const {
TimeSeriesClassificationData testData;
if( !crossValidationSetup ) return testData;
if( foldIndex >= kFoldValue ) return testData;
//Add the data to the training
testData.setNumDimensions( numDimensions );
UINT index = 0;
for(UINT i=0; i<crossValidationIndexs[ foldIndex ].size(); i++){
index = crossValidationIndexs[ foldIndex ][i];
testData.addSample( data[ index ].getClassLabel(), data[ index ].getData() );
}
return testData;
}
int main() {
vector<string> gestures(0,"");
GetFilesInDirectory(gestures, "rawdata");
CreateDirectory("processed", NULL);
sort(gestures.begin(), gestures.end());
data = vector<vector<vector<double > > >(gestures.size(), vector<vector<double > >(0,vector<double>(0,0)));
for(size_t i = 0; i < gestures.size(); i++) {
ifstream fin(gestures[i]);
int n; fin >> n;
// cerr << gestures[i] << endl;
// cerr << n << endl;
data[i] = vector<vector<double> >(n, vector<double>(NUMPARAM, 0));
for(int j = 0; j < n; j++) {
for(int k = 0; k < NUMPARAM; k++) {
fin >> data[i][j][k];
}
}
fin.close();
}
//Create a new instance of the TimeSeriesClassificationDataStream
TimeSeriesClassificationData trainingData;
// ax, ay, az
trainingData.setNumDimensions(3);
trainingData.setDatasetName("processed\\GestureTrainingData.txt");
ofstream labelfile("processed\\GestureTrainingDataLabels.txt");
UINT currLabel = 1;
Random random;
map<string, int> gesturenames;
for(size_t overall = 0; overall < gestures.size(); overall++) {
string nam = gestures[overall].substr(8,gestures[overall].find_first_of('_')-8);
if(gesturenames.count(nam)) currLabel = gesturenames[nam];
else {
currLabel = gesturenames.size()+1;
gesturenames[nam] = currLabel;
labelfile << currLabel << " " << nam << endl;
}
MatrixDouble trainingSample;
VectorDouble currVec( trainingData.getNumDimensions() );
for(size_t k = 1; k < data[overall].size(); k++) {
for(UINT j=0; j<currVec.size(); j++){
currVec[j] = data[overall][k][j];
}
trainingSample.push_back(currVec);
}
trainingData.addSample(currLabel, trainingSample);
}
for(size_t i = 0; i < gestures.size(); i++) {
MatrixDouble trainingSample;
VectorDouble currVec(trainingData.getNumDimensions());
for(UINT j = 0; j < currVec.size(); j++) {
currVec[j] = random.getRandomNumberUniform(-1.0, 1.0);
}
for(size_t k = 0; k < 100; k++) {
trainingSample.push_back(currVec);
}
trainingData.addSample(0, trainingSample);
}
//After recording your training data you can then save it to a file
if( !trainingData.save( "processed\\TrainingData.grt" ) ){
cout << "ERROR: Failed to save dataset to file!\n";
return EXIT_FAILURE;
}
//This can then be loaded later
if( !trainingData.load( "processed\\TrainingData.grt" ) ){
cout << "ERROR: Failed to load dataset from file!\n";
return EXIT_FAILURE;
}
//This is how you can get some stats from the training data
string datasetName = trainingData.getDatasetName();
string infoText = trainingData.getInfoText();
UINT numSamples = trainingData.getNumSamples();
UINT numDimensions = trainingData.getNumDimensions();
UINT numClasses = trainingData.getNumClasses();
cout << "Dataset Name: " << datasetName << endl;
cout << "InfoText: " << infoText << endl;
cout << "NumberOfSamples: " << numSamples << endl;
cout << "NumberOfDimensions: " << numDimensions << endl;
cout << "NumberOfClasses: " << numClasses << endl;
//You can also get the minimum and maximum ranges of the data
vector< MinMax > ranges = trainingData.getRanges();
cout << "The ranges of the dataset are: \n";
for(UINT j=0; j<ranges.size(); j++){
cout << "Dimension: " << j << " Min: " << ranges[j].minValue << " Max: " << ranges[j].maxValue << endl;
}
DTW dtw;
if( !dtw.train( trainingData ) ){
cerr << "Failed to train classifier!\n";
exit(EXIT_FAILURE);
}
dtw.enableNullRejection(true);
dtw.setNullRejectionCoeff(4);
dtw.enableTrimTrainingData(true, 0.1, 90);
//Save the DTW model to a file
if( !dtw.saveModelToFile("processed\\DTWModel.txt") ){
cerr << "Failed to save the classifier model!\n";
exit(EXIT_FAILURE);
}
trainingData.clear();
return EXIT_SUCCESS;
}
int main (int argc, const char * argv[])
{
//Create a new instance of the TimeSeriesClassificationData
TimeSeriesClassificationData trainingData;
//Set the dimensionality of the data (you need to do this before you can add any samples)
trainingData.setNumDimensions( 3 );
//You can also give the dataset a name (the name should have no spaces)
trainingData.setDatasetName("DummyData");
//You can also add some info text about the data
trainingData.setInfoText("This data contains some dummy timeseries data");
//Here you would record a time series, when you have finished recording the time series then add the training sample to the training data
UINT gestureLabel = 1;
MatrixDouble trainingSample;
//For now we will just add 10 x 20 random walk data timeseries
Random random;
for(UINT k=0; k<10; k++){//For the number of classes
gestureLabel = k+1;
//Get the init random walk position for this gesture
VectorDouble startPos( trainingData.getNumDimensions() );
for(UINT j=0; j<startPos.size(); j++){
startPos[j] = random.getRandomNumberUniform(-1.0,1.0);
}
//Generate the 20 time series
for(UINT x=0; x<20; x++){
//Clear any previous timeseries
trainingSample.clear();
//Generate the random walk
UINT randomWalkLength = random.getRandomNumberInt(90, 110);
VectorDouble sample = startPos;
for(UINT i=0; i<randomWalkLength; i++){
for(UINT j=0; j<startPos.size(); j++){
sample[j] += random.getRandomNumberUniform(-0.1,0.1);
}
//Add the sample to the training sample
trainingSample.push_back( sample );
}
//Add the training sample to the dataset
trainingData.addSample( gestureLabel, trainingSample );
}
}
//After recording your training data you can then save it to a file
if( !trainingData.saveDatasetToFile( "TrainingData.txt" ) ){
cout << "Failed to save dataset to file!\n";
return EXIT_FAILURE;
}
//This can then be loaded later
if( !trainingData.loadDatasetFromFile( "TrainingData.txt" ) ){
cout << "Failed to load dataset from file!\n";
return EXIT_FAILURE;
}
//This is how you can get some stats from the training data
string datasetName = trainingData.getDatasetName();
string infoText = trainingData.getInfoText();
UINT numSamples = trainingData.getNumSamples();
UINT numDimensions = trainingData.getNumDimensions();
UINT numClasses = trainingData.getNumClasses();
cout << "Dataset Name: " << datasetName << endl;
cout << "InfoText: " << infoText << endl;
cout << "NumberOfSamples: " << numSamples << endl;
cout << "NumberOfDimensions: " << numDimensions << endl;
cout << "NumberOfClasses: " << numClasses << endl;
//You can also get the minimum and maximum ranges of the data
vector< MinMax > ranges = trainingData.getRanges();
cout << "The ranges of the dataset are: \n";
for(UINT j=0; j<ranges.size(); j++){
cout << "Dimension: " << j << " Min: " << ranges[j].minValue << " Max: " << ranges[j].maxValue << endl;
}
//If you want to partition the dataset into a training dataset and a test dataset then you can use the partition function
//A value of 80 means that 80% of the original data will remain in the training dataset and 20% will be returned as the test dataset
TimeSeriesClassificationData testData = trainingData.partition( 80 );
//If you have multiple datasets that you want to merge together then use the merge function
if( !trainingData.merge( testData ) ){
cout << "Failed to merge datasets!\n";
return EXIT_FAILURE;
}
//If you want to run K-Fold cross validation using the dataset then you should first spilt the dataset into K-Folds
//A value of 10 splits the dataset into 10 folds and the true parameter signals that stratified sampling should be used
if( !trainingData.spiltDataIntoKFolds( 10, true ) ){
cout << "Failed to spiltDataIntoKFolds!\n";
return EXIT_FAILURE;
}
//After you have called the spilt function you can then get the training and test sets for each fold
for(UINT foldIndex=0; foldIndex<10; foldIndex++){
TimeSeriesClassificationData foldTrainingData = trainingData.getTrainingFoldData( foldIndex );
TimeSeriesClassificationData foldTestingData = trainingData.getTestFoldData( foldIndex );
}
//If need you can clear any training data that you have recorded
trainingData.clear();
return EXIT_SUCCESS;
}