qm.FeatureSpace

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "WeatherForcast",
       fields: [
           { name: "Weather", type: "string" },
           { name: "Date", type: "datetime" },
           { name: "TemperatureDegrees", type: "int" }
       ]
   }]
});
// put some records in the "WeatherForecast" store
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-27T11:00:00", TemperatureDegrees: 19 });
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-28T11:00:00", TemperatureDegrees: 22 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-29T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-30T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Scattered Showers", Date: "2015-05-31T11:00:00", TemperatureDegrees: 24 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-06-01T11:00:00", TemperatureDegrees: 27 });
// create a feature space
var ftr = new qm.FeatureSpace(base, { type: "numeric", source: "WeatherForcast", field: "TemperatureDegrees" });
// add a new feature extractor to the feature space
// it adds the new feature extractor to the pre-existing feature extractors in the feature space
ftr.addFeatureExtractor({ type: "text", source: "WeatherForcast", field: "Weather", normalize: true, weight: "tfidf" });
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Runners",
       fields: [
           { name: "ID", type: "int", primary: true },
           { name: "Name", type: "string" },
           { name: "BestTime", type: "float" }
       ]
   }]
});
// put some records in the "Runners" store
base.store("Runners").push({ ID: 110020, Name: "Eric Ericsson", BestTime: 134.33 });
base.store("Runners").push({ ID: 123307, Name: "Fred Friedrich", BestTime: 101.11 });
base.store("Runners").push({ ID: 767201, Name: "Appel Banana", BestTime: 1034.56 });
// create a feature space
var ftr = new qm.FeatureSpace(base, { type: "numeric", source: "Runners", field: "BestTime" });
// update the feature space
ftr.updateRecords(base.store("Runners").allRecords);
// clear the feature space (return the feature space to it's default values)
ftr.clear();
base.close();

// import qm module
var qm = require("qminer");
// create a base containing the store Class. Let the Name field be the primary field.
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "StudyGroups", type: "string_v" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Dean", StudyGroups: ["A", "D"] });
base.store("Class").push({ Name: "Chang", StudyGroups: ["B", "D"] });
base.store("Class").push({ Name: "Magnitude", StudyGroups: ["B", "C"] });
base.store("Class").push({ Name: "Leonard", StudyGroups: ["A", "B"] });
// create a feature space containing the multinomial feature extractor
var ftr = new qm.FeatureSpace(base, { type: "multinomial", source: "Class", field: "StudyGroups", values: ["A", "B", "C", "D"] });
// create a feature matrix out of the records of the store by using the feature space
// returns a sparse matrix equal to
// 1  0  0  1
// 0  1  1  1
// 0  0  1  0
// 1  1  0  0
var matrix = ftr.extractMatrix(base.store("Class").allRecords);
base.close();

// import qm module
var qm = require("qminer");
// create a base containing the store Class. Let the Name field be the primary field.
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "StudyGroups", type: "string_v" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Dean", StudyGroups: ["A", "D"] });
base.store("Class").push({ Name: "Chang", StudyGroups: ["B", "D"] });
base.store("Class").push({ Name: "Magnitude", StudyGroups: ["B", "C"] });
base.store("Class").push({ Name: "Leonard", StudyGroups: ["A", "B"] });
// create a feature space containing the multinomial feature extractor
var ftr = new qm.FeatureSpace(base, { type: "multinomial", source: "Class", field: "StudyGroups", values: ["A", "B", "C", "D"] });
// create a sparse feature matrix out of the records of the store by using the feature space
// returns a sparse matrix equal to
// [[(0, 1), (3, 1)], [(1, 1), (3, 1)], [(1, 1), (2, 1)], [(0, 1), (1, 1)]]
var sparseMatrix = ftr.extractSparseMatrix(base.store("Class").allRecords);
base.close();

// import qm module
var qm = require('qminer');
// create a base containing the store Class. Let the Name field be the primary field.
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "StudyGroup", type: "string" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Dean", StudyGroup: "A" });
base.store("Class").push({ Name: "Chang", StudyGroup: "D" });
base.store("Class").push({ Name: "Magnitude", StudyGroup: "C" });
base.store("Class").push({ Name: "Leonard", StudyGroup: "B" });
// create a new feature space
// the feature space is of dimensions [0, 4]; 4 is the dimension of the categorical feature extractor
// and 0 is the dimension of text feature extractor (the text feature extractor doesn't have any words,
// need to be updated for use).
var ftr = new qm.FeatureSpace(base, [
   { type: "text", source: "Class", field: "Name", normalize: false },
   { type: "categorical", source: "Class", field: "StudyGroup", values: ["A", "B", "C", "D"] }
]);
// get the sparse extractor vector for the first record in store
// the sparse vector will be [(0, 1)] - uses only the categorical feature extractor. There are no
// features in the text feature extractor.
var vec = ftr.extractSparseVector(base.store("Class")[0]);
base.close();

// import qm module
var qm = require('qminer');
// create a base containing the store Class. Let the Name field be the primary field.
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "StudyGroup", type: "string" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Jeff", StudyGroup: "A" });
base.store("Class").push({ Name: "Britta", StudyGroup: "D" });
base.store("Class").push({ Name: "Abed", StudyGroup: "C" });
base.store("Class").push({ Name: "Annie", StudyGroup: "B" });
// create a new feature space
// the feature space is of dimensions [0, 4]; 4 is the dimension of the categorical feature extractor
// and 0 is the dimension of text feature extractor (the text feature extractor doesn't have any words,
// need to be updated for use).
var ftr = new qm.FeatureSpace(base, [
   { type: "text", source: "Class", field: "Name", normalize: false },
   { type: "categorical", source: "Class", field: "StudyGroup", values: ["A", "B", "C", "D"] }
]);
// get the extractor vector for the first record in store
// the sparse vector will be [1, 0, 0, 0] - uses only the categorical feature extractor. There are no
// features in the text feature extractor.
var vec = ftr.extractVector(base.store("Class")[0]);
base.close();

// import qm module
var qm = require('qminer');
// create a new base with one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Academics",
       fields: [
           { name: "Name", type: "string" },
           { name: "Age", type: "int" },
           { name: "Gendre", type: "string" },
           { name: "Skills", type: "string_v" }
       ]
   }]
});
// create a new feature space
var ftr = new qm.FeatureSpace(base, [
    { type: "numeric", source: "Academics", field: "Age" },
    { type: "categorical", source: "Academics", field: "Gendre", values: ["Male", "Female"] },
    { type: "multinomial", source: "Academics", field: "Skills", values: ["Mathematics", "Programming", "Philosophy", "Languages", "Politics", "Cooking"] }
    ]);
// create a new dense vector
var vec = new qm.la.Vector([40, 0, 1, 0, 1, 1, 1, 0, 0]);
// filter the elements from the second feature extractor
var vec2 = ftr.filter(vec, 1); // returns vector [0, 0, 1, 0, 0, 0, 0, 0, 0]
// filter the elements from the second feature extractor, without keeping the offset
var vec3 = ftr.filter(vec, 1, false); // returns vector [0, 1]
// create a new sparse vector
var spVec = new qm.la.SparseVector([[0, 40], [2, 1], [4, 1], [5, 1], [6, 1]]);
// filter the elements from the second feature extractor
var spVec2 = ftr.filter(spVec, 1); // returns sparse vector [[2, 1]]
// filter the elements from the second feature extractor, without keeping the offset
var spVec3 = ftr.filter(spVec, 1, false); // returns sparse vector [[1, 1]]
base.close();

// import qm module
var qm = require("qminer");
// create a base containing the store Class. Let the Name field be the primary field.
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "StudyGroups", type: "string_v" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Dean", StudyGroups: ["A", "D"] });
base.store("Class").push({ Name: "Chang", StudyGroups: ["B", "D"] });
base.store("Class").push({ Name: "Magnitude", StudyGroups: ["B", "C"] });
base.store("Class").push({ Name: "Leonard", StudyGroups: ["A", "B"] });
// create a feature space containing the multinomial feature extractor
var ftr = new qm.FeatureSpace(base, [
{ type: "text", source: "Class", field: "Name" },
{ type: "multinomial", source: "Class", field: "StudyGroups", values: ["A", "B", "C", "D"] }
]);
// get the feature at position 2
var feature = ftr.getFeature(2); // returns "C", because the text extractor has no features at the moment
// update the feature space with the records of the store; see the method updateRecords
ftr.updateRecords(base.store("Class").allRecords);
// get the feature at position 2
var feature2 = ftr.getFeature(2); // returns "magnitude"
base.close();

// import qm module
var qm = require("qminer");
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "People",
       fields: [
           { name: "Name", type: "string" },
           { name: "Gendre", type: "string" },
           { name: "Age", type: "int" }
       ]
   }]
});
// create a feature space containing a categorical and numeric feature extractor
var ftr = new qm.FeatureSpace(base, [
   { type: "numeric", source: "People", field: "Age" },
   { type: "categorical", source: "People", field: "Gendre", values: ["Male", "Female"] }
]);
// get the name of the feature extractor with index 1
var extractorName = ftr.getFeatureExtractor(1); // returns "Categorical[Gendre]"
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "TheWitcherSaga",
       fields: [
           { name: "Title", type: "string" },
           { name: "YearOfRelease", type: "int" },
           { name: "EnglishEdition", type: "bool" }
       ]
   }]
});
// put some records in the store
base.store("TheWitcherSaga").push({ Title: "Blood of Elves", YearOfRelease: 1994, EnglishEdition: true });
base.store("TheWitcherSaga").push({ Title: "Time of Contempt", YearOfRelease: 1995, EnglishEdition: true });
base.store("TheWitcherSaga").push({ Title: "Baptism of Fire", YearOfRelease: 1996, EnglishEdition: true });
base.store("TheWitcherSaga").push({ Title: "The Swallow's Tower", YearOfRelease: 1997, EnglishEdition: false });
base.store("TheWitcherSaga").push({ Title: "Lady of the Lake", YearOfRelease: 1999, EnglishEdition: false });
base.store("TheWitcherSaga").push({ Title: "Season of Storms", YearOfRelease: 2013, EnglishEdition: false });
// create a feature space with the numeric feature extractor and update the feature space with the records in store
// for update, look the method updateRecords in feature space
var ftr = new qm.FeatureSpace(base, { type: "numeric", source: "TheWitcherSaga", field: "YearOfRelease", normalize: true });
ftr.updateRecords(base.store("TheWitcherSaga").allRecords);
// because of the numeric feature extractor having normalize: true and of the records update of feature space,
// the values are not equal to those of the records
// invert the value 0 using the numeric feature extractor
var inverse = ftr.invertFeature(0, 0); // returns the value 1994
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "TheWitcherSaga",
       fields: [
           { name: "Title", type: "string" },
           { name: "YearOfRelease", type: "int" },
           { name: "EnglishEdition", type: "bool" }
       ]
   }]
});
// put some records in the store
base.store("TheWitcherSaga").push({ Title: "Blood of Elves", YearOfRelease: 1994, EnglishEdition: true });
base.store("TheWitcherSaga").push({ Title: "Time of Contempt", YearOfRelease: 1995, EnglishEdition: true });
base.store("TheWitcherSaga").push({ Title: "Baptism of Fire", YearOfRelease: 1996, EnglishEdition: true });
base.store("TheWitcherSaga").push({ Title: "The Swallow's Tower", YearOfRelease: 1997, EnglishEdition: false });
base.store("TheWitcherSaga").push({ Title: "Lady of the Lake", YearOfRelease: 1999, EnglishEdition: false });
base.store("TheWitcherSaga").push({ Title: "Season of Storms", YearOfRelease: 2013, EnglishEdition: false });
// create a feature space with the numeric feature extractor and update the feature space with the records in store
// for update, look the method updateRecords in feature space
var ftr = new qm.FeatureSpace(base, { type: "numeric", source: "TheWitcherSaga", field: "YearOfRelease", normalize: true });
ftr.updateRecords(base.store("TheWitcherSaga").allRecords);
// get a feature vector for the second record
// because of the numeric feature extractor having normalize: true and of the records update of feature space, the values
// are not equal to those of the records, i.e. the value 1995 is now 0.105263
var ftrVec = ftr.extractVector(base.store("TheWitcherSaga")[1]);
// get the inverse of the feature vector
// the function returns the values to their first value, i.e. 0.105263 returns to 1995
var inverse = ftr.invertFeatureVector(ftrVec); // returns a vector [1995]
base.close();

// import qm module
var qm = require('qminer');
// create a new base
var base = new qm.Base({
  mode: "createClean",
  schema: {
    name: "FtrSpace",
    fields: [
      { name: "Value", type: "float" },
      { name: "Category", type: "string" },
      { name: "Categories", type: "string_v" },
    ]
  }
});
// populate the store
Store = base.store("FtrSpace");
Store.push({ Value: 1.0, Category: "a", Categories: ["a", "q"] });
Store.push({ Value: 1.1, Category: "b", Categories: ["b", "w"] });
Store.push({ Value: 1.2, Category: "c", Categories: ["c", "e"] });
Store.push({ Value: 1.3, Category: "a", Categories: ["a", "q"] });
// create a new feature space
var ftr = new qm.FeatureSpace(base, [
  { type: "numeric", source: "FtrSpace", normalize: true, field: "Value" },
  { type: "categorical", source: "FtrSpace", field: "Category", values: ["a", "b", "c"] },
  { type: "multinomial", source: "FtrSpace", field: "Categories", normalize: true, values: ["a", "b", "c", "q", "w", "e"] }
]);
// update the feature space with the first three record of the store
ftr.updateRecord(Store[0]);
ftr.updateRecord(Store[1]);
ftr.updateRecord(Store[2]);
// get the feature vectors of these records
ftr.extractVector(Store[0]); // returns the vector [0, 1, 0, 0, 1 / Math.sqrt(2), 0, 0, 1 / Math.sqrt(2), 0, 0]
ftr.extractVector(Store[1]); // returns the vector [1/2, 0, 1, 0, 0, 1 / Math.sqrt(2), 0, 0, 1 / Math.sqrt(2), 0]
ftr.extractVector(Store[2]); // returns the vector [1, 0, 0, 1, 0, 0, 1 / Math.sqrt(2), 0, 0, 1 / Math.sqrt(2)]
base.close();

// import qm module
var qm = require('qminer');
// create a new base
var base = new qm.Base({
  mode: "createClean",
  schema: {
    name: "FtrSpace",
    fields: [
      { name: "Value", type: "float" },
      { name: "Category", type: "string" },
      { name: "Categories", type: "string_v" },
    ]
  }
});
// populate the store
Store = base.store("FtrSpace");
Store.push({ Value: 1.0, Category: "a", Categories: ["a", "q"] });
Store.push({ Value: 1.1, Category: "b", Categories: ["b", "w"] });
Store.push({ Value: 1.2, Category: "c", Categories: ["c", "e"] });
Store.push({ Value: 1.3, Category: "a", Categories: ["a", "q"] });
// create a new feature space
var ftr = new qm.FeatureSpace(base, [
    { type: "numeric", source: "FtrSpace", normalize: true, field: "Value" },
    { type: "categorical", source: "FtrSpace", field: "Category", values: ["a", "b", "c"] },
    { type: "multinomial", source: "FtrSpace", field: "Categories", normalize: true, values: ["a", "b", "c", "q", "w", "e"] }
]);
// update the feature space with the record set
ftr.updateRecords(Store.allRecords);
// get the feature vectors of these records
ftr.extractVector(Store[0]); // returns the vector [0, 1, 0, 0, 1 / Math.sqrt(2), 0, 0, 1 / Math.sqrt(2), 0, 0]
ftr.extractVector(Store[1]); // returns the vector [1/3, 0, 1, 0, 0, 1 / Math.sqrt(2), 0, 0, 1 / Math.sqrt(2), 0]
ftr.extractVector(Store[2]); // returns the vector [2/3, 0, 0, 1, 0, 0, 1 / Math.sqrt(2), 0, 0, 1 / Math.sqrt(2)]
ftr.extractVector(Store[3]); // returns the vector [1, 1, 0, 0, 1 / Math.sqrt(2), 0, 0, 1 / Math.sqrt(2), 0, 0]
base.close();