Python PassiveAggressiveClassifier.decision_function方法代码示例

# 需要导入模块: from sklearn.linear_model import PassiveAggressiveClassifier [as 别名]
# 或者: from sklearn.linear_model.PassiveAggressiveClassifier import decision_function [as 别名]
class DeployedClassifierFactory:
	def __init__(self, term_doc_matrix, term_doc_matrix_factory, category, nlp=None):
		'''This is a class that enables one to train and save a classification model.

		Parameters
		----------
		term_doc_matrix : TermDocMatrix
		term_doc_matrix_factory : TermDocMatrixFactory
		category : str
			Category name
		nlp : spacy parser
		'''
		self._term_doc_matrix = term_doc_matrix
		self._term_doc_matrix_factory = term_doc_matrix_factory
		assert term_doc_matrix_factory._nlp is None
		assert term_doc_matrix_factory.category_text_iter is None
		self._category = category
		self._clf = None
		self._proba = None

	def passive_aggressive_train(self):
		'''Trains passive aggressive classifier

		'''
		self._clf = PassiveAggressiveClassifier(n_iter=50, C=0.2, n_jobs=-1, random_state=0)
		self._clf.fit(self._term_doc_matrix._X, self._term_doc_matrix._y)
		y_dist = self._clf.decision_function(self._term_doc_matrix._X)
		pos_ecdf = ECDF(y_dist[y_dist >= 0])
		neg_ecdf = ECDF(y_dist[y_dist <= 0])

		def proba_function(distance_from_hyperplane):
			if distance_from_hyperplane > 0:
				return pos_ecdf(distance_from_hyperplane) / 2. + 0.5
			elif distance_from_hyperplane < 0:
				return pos_ecdf(distance_from_hyperplane) / 2.
			return 0.5

		self._proba = proba_function
		return self

	def build(self):
		'''Builds Depoyed Classifier
		'''
		if self._clf is None:
			raise NeedToTrainExceptionBeforeDeployingException()
		return DeployedClassifier(self._category,
		                          self._term_doc_matrix._category_idx_store,
		                          self._term_doc_matrix._term_idx_store,
		                          self._term_doc_matrix_factory)

# 需要导入模块: from sklearn.linear_model import PassiveAggressiveClassifier [as 别名]
# 或者: from sklearn.linear_model.PassiveAggressiveClassifier import decision_function [as 别名]
	def test_main(self):
		categories, documents = get_docs_categories()
		clean_function = lambda text: '' if text.startswith('[') else text
		entity_types = set(['GPE'])
		term_doc_mat = (
			TermDocMatrixFactory(
				category_text_iter=zip(categories, documents),
				clean_function=clean_function,
				nlp=_testing_nlp,
				feats_from_spacy_doc=FeatsFromSpacyDoc(entity_types_to_censor=entity_types)
			).build()
		)
		clf = PassiveAggressiveClassifier(n_iter=5, C=0.5, n_jobs=-1, random_state=0)
		fdc = FeatsFromDoc(term_doc_mat._term_idx_store,
		                   clean_function=clean_function,
		                   feats_from_spacy_doc=FeatsFromSpacyDoc(
			                   entity_types_to_censor=entity_types)).set_nlp(_testing_nlp)
		tfidf = TfidfTransformer(norm='l1')
		X = tfidf.fit_transform(term_doc_mat._X)
		clf.fit(X, term_doc_mat._y)
		X_to_predict = fdc.feats_from_doc('Did sometimes march UNKNOWNWORD')
		pred = clf.predict(tfidf.transform(X_to_predict))
		dec = clf.decision_function(X_to_predict)

# 需要导入模块: from sklearn.linear_model import PassiveAggressiveClassifier [as 别名]
# 或者: from sklearn.linear_model.PassiveAggressiveClassifier import decision_function [as 别名]
  def run(self, nFold=3, loss='hinge', iter=10, verbose=1):
    log.debug("PA: run")
    (numx, numy) = self._network.shape

    pp = permutation(numx)
		
    model = PassiveAggressiveClassifier(loss=loss, n_iter=iter, verbose=verbose)
    model.fit(self._network, self._annotation.ravel())
    scores = model.decision_function(self._network)
    self._scores = self._convertScore(scores)

    fold = 0
    offset = 0
    meanroc = []
    labelIx = range(numx)
    while fold < nFold:
      log.debug("NV: ___ fold= %d ___" % fold)
      lastelem = int(min(numx, offset+floor(numx/nFold)))

      ix = []
      for index in pp[offset+1:lastelem]:
        ix.append(index)

      print lastelem

      offset = lastelem

      labeltmp = []
      for value in self._annotation:
        labeltmp.append(float(value))

      for index in ix:
        labeltmp[index] = 0

      model = PassiveAggressiveClassifier(loss=loss, n_iter=iter, verbose=verbose)
      model.fit(self._network, labeltmp)
      scores = model.decision_function(self._network)
      scores = self._convertScore(scores)

      score = []
      label = []
      protein = []
      for index in ix:
        score.append(float(scores[index]))
        label.append(int(self._annotation[index]))
        protein.append(int(self._proteinid[index]))

        self._foldlabels.append(int(self._annotation[index]))
        self._foldscores.append(float(scores[index]))
        self._foldproteins.append(int(self._proteinid[index]))

      auroc = self.AUROC(label, score)
      log.debug("AUROC= %.4f" % auroc)

      meanroc.append(auroc)

      fold += 1

    self._auroc = reduce(lambda x, y: x + y / float(len(meanroc)), meanroc, 0)
    auroc = self.AUROC(self._foldlabels, self._foldscores)

    self._TPR_FPR(self._foldlabels, self._foldscores)