def createDatasetMetaFeaturesInstances(self, dataset: Dataset, includeValueBased: bool):
directoryForDataset = Properties.DatasetInstancesFilesLocation + dataset.name
# File[] files;
if os.path.isdir(directoryForDataset):
_, _, filenames = next(os.walk(directoryForDataset))
if (filenames is not None) and (len(filenames)!=0):
Logger.Info('Candidate attributes for ' + dataset.name + ' were already calculated')
return
try:
os.mkdir(directoryForDataset)
except OSError as ex:
if ex.errno != errno.EEXIST:
Logger.Warn(f'getDatasetMetaFeaturesInstances -> Error creating directory {directoryForDataset}\nError: {ex}')
raise
# List<String> metadataTypes;
if includeValueBased:
# This is the line that activates the (time consuming) background datasets feature generation process
self.generateTrainingSetDatasetAttributes(dataset)
metadataTypes = [self.DATASET_BASED, self.OA_BASED, self.VALUES_BASED]
else:
# for pre-ranker model
self.generateTrainingSetDatasetAttributesWithoutValues(dataset)
metadataTypes = [self.DATASET_BASED, self.OA_BASED]
self.appendARFFFilesPerMetadataTypeForDataset(directoryForDataset, metadataTypes)
def produceScore(self, analyzedDatasets: Dataset,
currentScore: ClassificationResults,
completeDataset: Dataset, oa: OperatorAssignment,
candidateAttribute) -> float:
try:
mlam = MLAttributeManager()
if self.classifier == None:
Logger.Error("Classifier is not initialized")
raise Exception("Classifier is not initialized")
# we need to generate the features for this candidate attribute and then run the (previously) calculated classification model
oaba = OperatorAssignmentBasedAttributes()
oaAttributes: dict = {
} #oaba.getOperatorAssignmentBasedMetaFeatures(analyzedDatasets, oa)
candidateAttributes = {
k: v
for k, v in self.datasetAttributes.items()
}
for attributeInfo in oaAttributes.values():
candidateAttributes[len(candidateAttributes)] = attributeInfo
# We need to add the type of the classifier we're using
classifierAttribute = AttributeInfo(
"Classifier", outputType.Discrete, Properties.classifier,
len(Properties.classifiersForMLAttributesGeneration.split(
",")))
candidateAttributes[len(candidateAttributes)] = classifierAttribute
# In order to have attributes of the same set size, we need to add the class attribute. We don't know the true value, so we set it to negative
classAttrubute = AttributeInfo("classAttribute",
outputType.Discrete, 0, 2)
candidateAttributes[len(candidateAttributes)] = classAttrubute
# finally, we need to set the index of the target class
testInstances = mlam.generateValuesMatrix(candidateAttributes)
# testInstances.setClassIndex(classAtributeKey);
# evaluation = Evaluation(testInstances);
# evaluation.evaluateModel(classifier, testInstances);
# we have a single prediction, so it's easy to process
evaluationInfo = self.classifier.evaluateClassifier(testInstances)
prediction = evaluationInfo.predictions[0] #.predictions().get(0);
ci = ClassificationItem(prediction.actual(),
prediction.distribution())
return ci.getProbabilities()[
analyzedDatasets.getMinorityClassIndex()]
except Exception as ex:
Logger.Warn("oa working on " + oa.getName())
Logger.Error(
"FilterPreRankerEvaluator.produceScore -> Error in ML score generation : "
+ str(ex))
return -1
