コード例 #1
0
    def buildClassifier(self, instances):
        """
        builds the ZeroR classifier with the given data
        
        Parameter(s):
        
            'instances' -- the data to build the classifier from
        """

        self.getCapabilities().testWithFail(instances)

        # remove instances with missing class
        instances = Instances(instances)
        instances.deleteWithMissingClass()

        sumOfWeights = 0
        self.__Class = instances.classAttribute()
        self.__ClassValue = 0
        self.__Counts = None

        if (instances.classAttribute().isNumeric()):
            self.__Counts = None
        elif (instances.classAttribute().isNominal()):
            self.__Counts = jarray.zeros(instances.numClasses(), 'd')
            for i in range(len(self.__Counts)):
                self.__Counts[i] = 1
            sumOfWeights = instances.numClasses()

        enu = instances.enumerateInstances()
        while (enu.hasMoreElements()):
            instance = enu.nextElement()
            if (not instance.classIsMissing()):
                if (instances.classAttribute().isNominal()):
                    self.__Counts[int(
                        instance.classValue())] += instance.weight()
                else:
                    self.__ClassValue += instance.weight(
                    ) * instance.classValue()
                sumOfWeights += instance.weight()

        if (instances.classAttribute().isNumeric()):
            if (Utils.gr(sumOfWeights, 0)):
                self.__ClassValue /= sumOfWeights
        else:
            self.__ClassValue = Utils.maxIndex(self.__Counts)
            Utils.normalize(self.__Counts, sumOfWeights)

        return
コード例 #2
0
ファイル: JeroR.py プロジェクト: TheSengers/Weka
    def buildClassifier(self, instances):
        """
        builds the ZeroR classifier with the given data
        
        Parameter(s):
        
            'instances' -- the data to build the classifier from
        """
        
        self.getCapabilities().testWithFail(instances)
    
        # remove instances with missing class
        instances = Instances(instances)
        instances.deleteWithMissingClass()
        
        sumOfWeights      = 0
        self.__Class      = instances.classAttribute()
        self.__ClassValue = 0
        self.__Counts     = None
        
        if (instances.classAttribute().isNumeric()):
            self.__Counts = None
        elif (instances.classAttribute().isNominal()):
            self.__Counts = jarray.zeros(instances.numClasses(), 'd')
            for i in range(len(self.__Counts)):
                self.__Counts[i] = 1
            sumOfWeights = instances.numClasses()

        enu = instances.enumerateInstances()
        while (enu.hasMoreElements()):
            instance = enu.nextElement()
            if (not instance.classIsMissing()):
                if (instances.classAttribute().isNominal()):
                    self.__Counts[int(instance.classValue())] += instance.weight()
                else:
                    self.__ClassValue += instance.weight() * instance.classValue()
                sumOfWeights += instance.weight()
            
        if (instances.classAttribute().isNumeric()):
            if (Utils.gr(sumOfWeights, 0)):
                self.__ClassValue /= sumOfWeights
        else:
            self.__ClassValue = Utils.maxIndex(self.__Counts)
            Utils.normalize(self.__Counts, sumOfWeights)
                    
        return
コード例 #3
0
 def load_model(self, model, arff):
     try:
         j48 = J48()
         options = ('-i', '-l', model, '-T', arff)
         objectInputFileName = Utils.getOption('l', options);
         if len(objectInputFileName) == 0:
             print "No training file and no object input file given."
             raise
         inputStream = InputStream
         inputStream = FileInputStream(objectInputFileName)
         objectInputStream = ObjectInputStream(inputStream)
         j48 = objectInputStream.readObject()
         return j48
     except:
         raise
コード例 #4
0
ファイル: JeroR.py プロジェクト: AndrewSviridov/wekaexamples
class JeroR(AbstractClassifier, JythonSerializableObject):
    """
    JeroR is a Jython implementation of the Weka classifier ZeroR
    
    'author' -- FracPete (fracpete at waikato dot ac dot nz)
    
    'version' -- $Revision: 10229 $
    """

    # the documentation can be generated with HappyDoc:
    #    http://happydoc.sourceforge.net/
    # Example command:
    #     happydoc --title Weka -d ./doc ./src

    # the chosen class value
    __ClassValue = Utils.missingValue()

    # the class attribute
    __Class = None

    # the counts for each class label
    __Counts = None

    def listOptions(self):
        """
        Returns an enumeration describing the available options.
        
        Return:
         
            an enumeration of all the available options.
        """

        return AbstractClassifier.listOptions(self)

    def setOptions(self, options):
        """
        Parses a given list of options.
         
        Parameter(s):
        
            'options' -- the list of options as an array of strings
        """

        AbstractClassifier.setOptions(self, options)

        return

    def getOptions(self):
        """
        Gets the current settings of the Classifier as string array.
         
        Return:
         
            an array of strings suitable for passing to setOptions
        """

        return AbstractClassifier.getOptions(self)

    def getCapabilities(self):
        """
        returns the capabilities of this classifier
        
        Return:
        
            the capabilities of this classifier
        """

        result = AbstractClassifier.getCapabilities(self)

        # attributes
        result.enable(Capability.NOMINAL_ATTRIBUTES)
        result.enable(Capability.NUMERIC_ATTRIBUTES)
        result.enable(Capability.DATE_ATTRIBUTES)
        result.enable(Capability.STRING_ATTRIBUTES)
        result.enable(Capability.RELATIONAL_ATTRIBUTES)
        result.enable(Capability.MISSING_VALUES)

        # class
        result.enable(Capability.NOMINAL_CLASS)
        result.enable(Capability.NUMERIC_CLASS)
        result.enable(Capability.DATE_CLASS)
        result.enable(Capability.MISSING_CLASS_VALUES)

        # instances
        result.setMinimumNumberInstances(0)

        return result

    def buildClassifier(self, instances):
        """
        builds the ZeroR classifier with the given data
        
        Parameter(s):
        
            'instances' -- the data to build the classifier from
        """

        self.getCapabilities().testWithFail(instances)

        # remove instances with missing class
        instances = Instances(instances)
        instances.deleteWithMissingClass()

        sumOfWeights = 0
        self.__Class = instances.classAttribute()
        self.__ClassValue = 0
        self.__Counts = None

        if (instances.classAttribute().isNumeric()):
            self.__Counts = None
        elif (instances.classAttribute().isNominal()):
            self.__Counts = jarray.zeros(instances.numClasses(), 'd')
            for i in range(len(self.__Counts)):
                self.__Counts[i] = 1
            sumOfWeights = instances.numClasses()

        enu = instances.enumerateInstances()
        while (enu.hasMoreElements()):
            instance = enu.nextElement()
            if (not instance.classIsMissing()):
                if (instances.classAttribute().isNominal()):
                    self.__Counts[int(
                        instance.classValue())] += instance.weight()
                else:
                    self.__ClassValue += instance.weight(
                    ) * instance.classValue()
                sumOfWeights += instance.weight()

        if (instances.classAttribute().isNumeric()):
            if (Utils.gr(sumOfWeights, 0)):
                self.__ClassValue /= sumOfWeights
        else:
            self.__ClassValue = Utils.maxIndex(self.__Counts)
            Utils.normalize(self.__Counts, sumOfWeights)

        return

    def classifyInstance(self, instance):
        """
        returns the prediction for the given instance
        
        Parameter(s):
        
            'instance' -- the instance to predict the class value for

        Return:
        
            the prediction for the given instance
        """

        return self.__ClassValue

    def distributionForInstance(self, instance):
        """
        returns the class distribution for the given instance
        
        Parameter(s):
        
            'instance' -- the instance to calculate the class distribution for
            
        Return:
        
            the class distribution for the given instance
        """

        result = None
        if (self.__Counts == None):
            result = jarray.zeros(1, 'd')
            result[0] = self.__ClassValue
        else:
            result = self.__Counts[:]

        return result

    def toString(self):
        """
        Prints a string representation of the classifier

        Return:
            
            string representation of the classifier
        """

        if (self.__Class == None):
            return "JeroR: No model built yet."
        if (self.__Counts == None):
            return "JeroR predicts class value: " + str(self.__ClassValue)
        else:
            return "JeroR predicts class value: " + str(
                self.__Class.value(int(self.__ClassValue)))