def predict(self, instance: Instance) -> str:
"""
The predict method takes an Instance as an input. First it gets the size of prior distribution and loops this
size times. Then it gets the possible class labels and and calculates metric value. At the end, it returns the
class which has the maximum value of metric.
PARAMETERS
----------
instance : Instance
Instance to predict.
RETURNS
-------
str
The class which has the maximum value of metric.
"""
maxMetric = -10000000
if isinstance(instance, CompositeInstance):
predicatedClass = instance.getPossibleClassLabels()[0]
size = len(instance.getPossibleClassLabels())
else:
predicatedClass = self.priorDistribution.getMaxItem()
size = len(self.priorDistribution)
for i in range(size):
if isinstance(instance, CompositeInstance):
Ci = instance.getPossibleClassLabels()[i]
else:
Ci = self.priorDistribution.getItem(i)
if self.priorDistribution.containsItem(Ci):
metric = self.calculateMetric(instance, Ci)
if metric > maxMetric:
maxMetric = metric
predicatedClass = Ci
return predicatedClass
def nearestNeighbors(self, instance: Instance) -> InstanceList:
"""
The nearestNeighbors method takes an Instance as an input. First it gets the possible class labels, then loops
through the data InstanceList and creates new list of KnnInstances and adds the corresponding data with
the distance between data and given instance. After sorting this newly created list, it loops k times and
returns the first k instances as an InstanceList.
PARAMETERS
----------
instance : Instance
Instance to find nearest neighbors
RETURNS
-------
InstanceList
The first k instances which are nearest to the given instance as an InstanceList.
"""
result = InstanceList()
instances = []
possibleClassLabels = []
if isinstance(instance, CompositeInstance):
possibleClassLabels = instance.getPossibleClassLabels()
for i in range(self.__data.size()):
if not isinstance(instance, CompositeInstance) or self.__data.get(
i).getClassLabel() in possibleClassLabels:
instances.append(
KnnInstance(
self.__data.get(i),
self.__distanceMetric.distance(self.__data.get(i),
instance)))
instances.sort(key=cmp_to_key(self.makeComparator()))
for i in range(min(self.__k, len(instances))):
result.add(instances[i].instance)
return result
def predict(self, instance: Instance) -> str:
"""
The predict method performs prediction on the root node of given instance, and if it is null, it returns the
possible class labels. Otherwise it returns the returned class labels.
PARAMETERS
----------
instance : Instance
Instance make prediction.
RETURNS
-------
str
Possible class labels.
"""
predictedClass = self.__root.predict(instance)
if predictedClass is None and isinstance(instance, CompositeInstance):
predictedClass = instance.getPossibleClassLabels()
return predictedClass
def predict(self, instance: Instance) -> str:
"""
The predict method takes an Instance as an input and returns the entry of distribution which has the maximum
value.
PARAMETERS
----------
instance : Instance
Instance to make prediction.
RETURNS
-------
str
The entry of distribution which has the maximum value.
"""
if isinstance(instance, CompositeInstance):
possibleClassLabels = instance.getPossibleClassLabels()
return self.distribution.getMaxItemIncludeTheseOnly(
possibleClassLabels)
else:
return self.distribution.getMaxItem()
def predict(self, instance: Instance) -> str:
"""
The predict method takes an Instance as an input, converts it to a Vector and calculates the Matrix y by
multiplying Matrix W with Vector x. Then it returns the class label which has the maximum y value.
PARAMETERS
----------
instance : Instance
Instance to predict.
RETURNS
-------
str
The class label which has the maximum y.
"""
self.createInputVector(instance)
self.calculateOutput()
if isinstance(instance, CompositeInstance):
return self.predictWithCompositeInstance(
instance.getPossibleClassLabels())
else:
return self.classLabels[self.y.maxIndex()]
def predict(self, instance: Instance) -> str:
"""
The predict method takes an Instance as an input and finds the nearest neighbors of given instance. Then
it returns the first possible class label as the predicted class.
PARAMETERS
----------
instance : Instance
Instance to make prediction.
RETURNS
-------
str
The first possible class label as the predicted class.
"""
nearestNeighbors = self.nearestNeighbors(instance)
if isinstance(instance,
CompositeInstance) and nearestNeighbors.size() == 0:
predictedClass = instance.getPossibleClassLabels()[0]
else:
predictedClass = Model.getMaximum(
nearestNeighbors.getClassLabels())
return predictedClass
def predict(self, instance: Instance) -> str:
"""
The predict method gets an Instance as an input and retrieves the possible class labels as an ArrayList. Then
selects a random number as an index and returns the class label at this selected index.
PARAMETERS
----------
instance : Instance
Instance to make prediction.
RETURNS
-------
str
The class label at the randomly selected index.
"""
if isinstance(instance, CompositeInstance):
possibleClassLabels = instance.getPossibleClassLabels()
size = len(possibleClassLabels)
index = random.randint(0, size)
return possibleClassLabels[index]
else:
size = len(self.__classLabels)
index = random.randrange(size)
return self.__classLabels[index]