基于python的支持向量机

zzl001

　　这个要和svmlight配合一起使用
　　Python语言: 高亮代码由发芽网提供
001 # svmlight.py
002 #
003 # Author: Clint Burfoot <clint@burfoot.info>
004 #
005 
006 """
007 An interface class for U{SVM light<http://svmlight.joachims.org/>}
008 """
009 
010 import os
011 import tempfile
012 import math
013 from subprocess import call
014 
015 class SVMLight:
016     """
017     An interface class for U{SVM light<http://svmlight.joachims.org/>}
018     
019     This class currently supports classification with default options 
020     only. It calls the SVMLight binaries as external programs.
021     
022     Future versions should add a SWIG interface and support for use of 
023     non-default SVMlight options.
024     
025     C{SVMLight} reads sparse feature vectors - dictionaries with 
026     numeric keys, representing features, and arbitrary numeric values.
027     """
028     
029     learn_binary = "svm_learn"
030     classify_binary = "svm_classify"
031     
032     def __init__(self, svm_path, labels=None, vectors=None, model=None, 
033                  cleanup=False):
034         """
035         Trains a new classifier.
036         
037         @type svm_path: C{str}
038         @param svm_path: The filesystem path to the SVMLight binaries
039         @type labels: C{tuple}
040         @param labels: A tuple of boolean training set labels.
041         @type vectors: C{tuple}
042         @param vectors: A tuple of sparse feature vectors.
043         @type model: A C{tuple} of C{str}
044         @param model: The lines from an SVMlight model file. Specify this 
045         instead of C{labels} and C{vectors} to use a pre-trained classifier.
046         """
047         self._svm_learn = os.sep.join((svm_path, SVMLight.learn_binary))
048         self._svm_classify = os.sep.join((svm_path, SVMLight.classify_binary))
049         self._cleanup = cleanup
050         self._devnull = None
051         
052         self._directory = tempfile.mkdtemp()
053         self._example_fname = os.sep.join((self._directory, "example"))
054         self._model_fname = os.sep.join((self._directory, "model"))
055         self._input_fname = os.sep.join((self._directory, "input"))
056         self._output_fname = os.sep.join((self._directory, "output"))
057         
058         if model is not None:
059             self._write_model(self._model_fname, model)
060             self.model = model
061         elif len(labels) != len(vectors):
062             raise ValueError("labels and vectors arrays are different lengths")
063         
064         self._write_vectors(self._example_fname, labels, vectors)
065         ret = call((self._svm_learn, self._example_fname, self._model_fname),
066                    stdout=self.devnull)
067         assert ret == 0
068         if model is None:
069             self.model = self._read_model()
070 
071     def _get_devnull(self):
072         # Return a handle to /dev/null (or windows equivalent).
073         if self._devnull is None:
074             if os.name == 'posix':
075                 self._devnull = open("/dev/null", "w")
076             else:
077                 # Assume we're on windows.
078                 self._devnull = open("NUL:", "w")              
079         return self._devnull
080     devnull = property(_get_devnull)
081 
082     def __getstate__(self):
083         state = self.__dict__.copy()
084         state['_devnull'] = None
085         return state
086      
087     def classify(self, vectors):
088         """
089         Classify feature vectors.
090         
091         @type vectors: C{tuple}
092         @param vectors: A tuple of sparse binary feature vectors.
093         @rtype: C{tuple}
094         @return: A tuple of C{float} vector classifications.
095         """
096         self._write_vectors(self._input_fname, ["0" for v in vectors], vectors)
097         ret = call((self._svm_classify, self._input_fname, self._model_fname, 
098                     self._output_fname), stdout=self.devnull)
099         assert ret == 0
100         results = self._read_classification()
101         assert len(results) == len(vectors)
102         return results
103     
104     def _write_vectors(self, fname, labels, vectors):
105         # Writes the given array to the given filename with the given labels.
106         # Vectors are written in the SVMlight format.
107         file = open(fname, "w")
108         assert len(labels) == len(vectors)
109         for i in range(0, len(labels)):
110             label = "-1"
111             if labels[i]:
112                 label = "1"
113             feature_strings = list()
114             features = vectors[i].keys()
115             features.sort()
116             for feature in features:
117                 feature_strings.append("%d:%s" % (feature + 1, 
118                                                   str(vectors[i][feature])))
119             file.write("%s %s\n" % (label, " ".join(feature_strings)))
120         file.close()
121     
122     def _write_model(self, fname, model):
123         # Writes the model file.
124         file = open(fname, "w")
125         for line in model:
126             file.write("%s\n" % line)
127         file.close()
128         
129     def _read_classification(self):
130         # Reads the SVMlight output file.
131         file = open(self._output_fname, "r")
132         result = []
133         for line in file.readlines():
134             result.append(float(line))
135         file.close()
136         assert len(result) > 0
137         return result
138     
139     def _read_model(self):
140         # Reads the SVMlight model file.
141         file = open(self._model_fname, "r")
142         result = []
143         for line in file.readlines():
144             line = line.rstrip()
145             result.append(line)
146         file.close()
147         assert len(result) > 0
148         return result
149         
150     def __del__(self):
151         if self._cleanup:
152             for fname in os.listdir(self._directory):
153                 os.unlink(os.sep.join((self._directory, fname)))
154             os.rmdir(self._directory)