Python SVC.predict_proba方法代码示例

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def pipeline(iteration, C, gamma, random_seed):
    x_train, _x, y_train, _y = train_test_split(train_x, train_y, test_size=0.4, random_state=random_seed)
    print x_train.shape
    clf = SVC(
        C=C,
        kernel="rbf",
        gamma=gamma,
        probability=True,
        cache_size=7000,
        class_weight="balanced",
        verbose=True,
        random_state=random_seed,
    )
    clf.fit(x_train, y_train)
    # predict test set
    pred = clf.predict_proba(test_x)
    test_result = pd.DataFrame(columns=["Idx", "score"])
    test_result.Idx = test_Idx
    test_result.score = pred[:, 1]
    test_result.to_csv("./test/svm_{0}.csv".format(iteration), index=None)
    # predict val set
    pred = clf.predict_proba(val_x)
    val_result = pd.DataFrame(columns=["Idx", "score"])
    val_result.Idx = val_Idx
    val_result.score = pred[:, 1]
    val_result.to_csv("./val/svm_{0}.csv".format(iteration), index=None)

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
    def go_by_category_2(category):
        input, targets, scaler = TrainingFactory.get_training_data_by_category(category,10000)
        input_train, input_test, target_train, target_test = train_test_split(input, targets, test_size=0.1)

        test_data_sparse = TestingFactory.get_test_data(limit=1000)
        test_data_scaled = scaler.transform(test_data_sparse)
        test_data = csr_matrix(test_data_scaled)

        classif = SVC(kernel='rbf',C=0.1, tol=0.001, probability=True)
        classif.fit(input_train, target_train)

        output_targets_proba = classif.predict_proba(input_test)

        outputs_predicted_proba = [item[1] for item in output_targets_proba]
        output_targets = classif.predict(input_test)

        # print output_targets.tolist()
        # print outputs_predicted_proba
        # print target_test

        print log_loss(target_test, output_targets)
        accuracy = accuracy_score(target_test, output_targets)
        print accuracy
        print confusion_matrix(target_test, output_targets)


        testing_output = classif.predict_proba(test_data)
        testing_output_proba = [item[1] for item in testing_output]
        print testing_output_proba

        return accuracy, output_targets, testing_output_proba

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("-i", "--image", required = True, help = "Path to the image")
    args = vars(ap.parse_args())

    image = cv2.imread(args["image"])
    rects, img = detect(image)

    cropped = []

    for idx, (x1, y1, x2, y2) in enumerate(rects):
        crop_img = image[y1:y1 + (y2 - y1), x1:x1 + (x2 - x1)]
        crop_img = cv2.resize(crop_img, (100,100), interpolation = cv2.INTER_AREA)
        cv2.imshow("image" + str(idx), crop_img)
        new_img = crop_img.reshape(crop_img.shape[0] * crop_img.shape[1], 3)
        cropped.append(new_img.flatten())

    # reduce feature size
    cropped_pca = []
    pca = RandomizedPCA(n_components=100)
    cropped_pca = pca.fit_transform(cropped)

    # training (hardcoded for now)
    clf   = SVC(probability=True)
    train = cropped_pca[:7]
    test  = cropped_pca[7:13]
    # clf.fit([[0,0],[1,1]], [1, 2])
    clf.fit(train, [1,2,2,1,2,1,1])

    for item in test:
        print clf.predict_proba(item)
        print clf.predict(item)

    cv2.waitKey(0)

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def svm_classify(threshold):
    
    data=pd.DataFrame()
    i=0
    xprev=0
    xprev2=0
    for x in cot.columns[:-1]:
        data[x]=cot[x]/pd.rolling_mean(cot[x],5)
        data[x+'_polynomial2']=data[x]*data[x]
        data[x+'_polynomial3']=data[x]*data[x]*data[x]
        if (xprev!=0):
            data[x+'_polynomial_x_2']=data[x]*data[xprev]
        if (xprev2!=0):
            data[x+'_polynomial_x_3']=data[x]*data[xprev2]*data[xprev]
        i=i+1
        xprev=x
        xprev2=xprev
    
    data['return']=((brent.shift(-5).Rate/brent.shift(-1).Rate)-1)>0
    data=data[8:].dropna(1)
    x_train, x_test, y_train, y_test = train_test_split(data.iloc[:-1,:-1], data.iloc[:-1,-1], test_size=0.5)
    gbc=SVC (kernel='rbf',probability=True,C=1)
    gbc.fit(x_train,y_train)
    #min_max_scaler=MinMaxScaler()
    #mms=min_max_scaler.fit(list(max(a) for a in gbc.predict_proba(x_train)))
    pr=list(max(a) for a in gbc.predict_proba(x_test))
    Y=pd.DataFrame()
    Y['actual']=y_test
    Y['predicted']=gbc.predict(x_test)
    Y['P']=mms.transform(list(max(a) for a in gbc.predict_proba(x_test)))
    Y_filtered=Y[Y.P>threshold]
    cm=confusion_matrix(Y_filtered.actual,Y_filtered.predicted)
    return [gbc.score(x_test,y_test,pr>threshold),cm,'Prediction of UP is %s; P = %s' %(gbc.predict(data.iloc[-1:,:-1])[0],
     list((max(x)) for x in gbc.predict_proba(data.iloc[-1:,:-1]))[0]
     ),brent]

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def svm_grid_search():

	#get data
	training_input,training_target,validation_input,validation_target = prepare_input()

	#set up scorer for grid search. log-loss is error, not score, so set greater_is_better to false,
	#and log-loss requires a probability
	log_loss_scorer = make_scorer(log_loss,greater_is_better=False,needs_proba=True)

	training_input = training_input[:100000]
	training_target = training_target[:100000]

	print training_input.shape[0]
	print training_target.shape[0]

	start = time.time()
	svm = SVC(random_state=31,probability=True)
	
	
	svm_parameters = {'C':[.001,.01,.1,1,10,100],'kernel':["rbf","sigmoid"]}
	svm_grid_obj = GridSearchCV(svm,svm_parameters,log_loss_scorer,verbose=2,n_jobs=-1)
	svm_grid_obj = svm_grid_obj.fit(training_input,training_target)
	svm = svm_grid_obj.best_estimator_
	print "Best params: " + str(svm_grid_obj.best_params_)	
	svm_train_error = log_loss(training_target,svm.predict_proba(training_input))
	svm_validation_error = log_loss(validation_target,svm.predict_proba(validation_input))
	print "Best SVM training error: {:02.4f}".format(svm_train_error)
	print "Best SVM validation error: {:02.4f}".format(svm_validation_error)
	end = time.time()
	print "RF grid search took {:02.4f} seconds".format(end-start)

	return svm

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def svm_solver(train_data, train_label, validation, test, dimreduce, convertbinary) :
    """
    """
    logging.info ('begin to train the svm classifier')

    # train_data = train_data[:100,:]
    # validation = validation[:100,:]
    # test = test[:100,:]
    # train_label = train_label[:100]
    train_data, validation, test = dimreduce(train_data, train_label, validation, test)
    # print new_train_data.shape
    train_data, validation, test = convertbinary(train_data, validation, test)

    """
    svc = SVC ()
    params_rbf = {"kernel": ['rbf'],
             "class_weight": ['auto'],
             "C": [0.1 ,0.2 ,0.3 ,0.5 ,1, 2, 3, 5, 10],
             "gamma": [0.01, 0.03,  0.05, 0.1, 0.2, 0.3, 0.5],
             "tol": 10.0** -np.arange(1, 5),
             "random_state": [1000000007]}
    logging.info ("Hyperparameter opimization using RandomizedSearchCV...")
    rand_search_result = RandomizedSearchCV (svc, param_distributions = params_rbf, n_jobs = -1, cv = 3, n_iter = 30)
    # rand_search_result = GridSearchCV (svc , param_grid = params_rbf , n_jobs = 8  , cv = 3)
    rand_search_result.fit (train_data , train_label)
    params = tools.report (rand_search_result.grid_scores_)
    """
    params = {'kernel': 'poly', 'C': 0.1, 'random_state': 1000000007, 'tol': 0.001, 'gamma': 0.1, 'class_weight': 'auto'}
    svc = SVC (probability = True, **params)

    svc.fit (train_data , train_label)
    evaluate.get_auc (svc.predict_proba (validation)[:,1])
    return svc.predict_proba (test)[:,1]

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
class NormalSVCTrainer(AbstractLearner):
    def __init__(self, kernel='linear', gamma='auto', penalty=1.0, cache=200, scale=True, scheme='ovr', class_w='balanced'):
        self.learner = SVC(C=penalty, kernel=kernel, gamma=gamma, probability=True, cache_size=cache, decision_function_shape=scheme,
                           class_weight=class_w)
        self.kernel = kernel
        self.gamma = gamma
        self.penalty = penalty
        self.scheme = scheme
        self.scale = scale

    def _train(self, x_train, y_train):
        if self.scale:
            self.scaler = preprocessing.StandardScaler().fit(x_train)
            x_scaled = self.scaler.transform(x_train)
            self.learner = self.learner.fit(x_scaled, y_train)
        else:
            self.learner = self.learner.fit(x_train, y_train)

    def _predict(self, x):
        if self.scale:
            x_scaled = self.scaler.transform(x)
            return self.learner.predict(x_scaled)
        else:
            return self.learner.predict(x)

    def _predict_proba(self, x):
        if self.scale:
            x_scaled = self.scaler.transform(x)
            return self.learner.predict_proba(x_scaled)
        else:
            return self.learner.predict_proba(x)

    def __str__(self):
        return 'SVC (kernel=%s, penalty: %f, scheme: %s, gamma=%s)' % \
               (self.kernel, self.penalty, self.scheme, str(self.gamma))

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
    def grid_searcher(self):
        X_train, X_test, Y_train, Y_test = self.cv_data[-1]
        X_train = np.vstack((X_train, X_test))
        Y_train = np.concatenate((Y_train, Y_test))
        stratifiedCV = StratifiedKFold(Y_train, 10)

        ansDict = {}
        ansDict["train"] = {}
        ansDict["test"] = {}

        C_range = 10.0 ** np.arange(-4, 9)
        gamma_range = 10.0 ** np.arange(-5, 4)
        for ind, i in enumerate(C_range):
            for jnd, j in enumerate(gamma_range):
                # Cantor's pairs
                dictInd = ((ind + jnd + 2) ** 2 + (ind + 1) - (jnd + 1)) / 2
                ansDict["train"][dictInd] = []
                ansDict["test"][dictInd] = []
                for train, test in stratifiedCV:
                    X_trainT, X_testT, Y_trainT, Y_testT = (
                        X_train[train, :],
                        X_train[test, :],
                        Y_train[train, :],
                        Y_train[test, :],
                    )
                    svc = SVC(kernel="rbf", C=i, gamma=j, probability=True, class_weight="auto")
                    svc.fit(X_trainT, Y_trainT)
                    ansDict["train"][dictInd].append(logloss(Y_trainT, svc.predict_proba(X_trainT)[:, 1]))
                    ansDict["test"][dictInd].append(svc.predict_proba(self.testMat)[:, 1])

        meanScores = []
        for i, j in ansDict["train"].items():
            wut = np.array(j)
            meanScores.append(wut.mean())

        meanScores = np.array(meanScores)
        meanScores[meanScores < 0] = 1.0
        print(meanScores.min())
        paramGood = np.where(meanScores == meanScores.min())[0][0]
        testPred = ansDict["test"][paramGood]
        finalPred = np.vstack(testPred).mean(axis=0)

        def write_prediction(f):
            g = open("sc_prediction.csv", "w")
            for i in f:
                g.write(str(i) + "\n")
            g.close()

        write_prediction(finalPred)

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def support_vector(XTrain, yTrain, XTest):
    svm = SVC(kernel='linear',probability = True)
    svm.fit(XTrain, yTrain)
    scores = svm.predict_proba(XTest)
    labels = svm.predict(XTest)

    return (labels, scores)

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
class LinearSVMPredictor(PredictorBase):
    '''
    Linear SVM
    '''

    def __init__(self, animal_type):
        self.animal_type = animal_type
        self.clf = SVC(
            kernel="linear", C=1.0, probability=True, random_state=0)

    def fit(self, X_train, y_train):
        self.clf.fit(X_train, y_train)

    def predict(self, X_test):
        predictions = self.clf.predict_proba(X_test)
        predictions_df = self.bundle_predictions(predictions)

        return predictions_df

    def find_best_params(self):
        parameters = {'kernel': ["linear"], 'C': [0.025, 1.0]}
        svc = SVC()
        clf = grid_search.GridSearchCV(svc, parameters)
        train_data = get_data('../data/train.csv')
        train_data = select_features(train_data, self.animal_type)
        X = train_data.drop(['OutcomeType'], axis=1)
        y = train_data['OutcomeType']
        clf.fit(X, y)
        print clf.best_params_

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def svc((C, gamma)):
    s = SVC(C=C, gamma=gamma, probability=True)
    start = time.time()
    s.fit(X[:border], y[:border])
    train_time = time.time() - start
    pred = s.predict_proba(X[border:])[:, 0]
    test_time = (time.time() - start) - train_time

    # This is the literal is-it-the-right-answer  binary score.
    # This measure is what we try to maximize but its relation to question
    # accuracy is complicated
    accu = np.sum((pred > 0.5) == y) / len(y)

    ###  This is the actual question prediction error, in bits
    # First, find the probabilities
    pred_y = pred * y[border:] # These are the probabilities for right answers
    pred_y = pred_y[pred_y.nonzero()]   # the same, stripped of 0's
    mean_bits = np.mean(-np.log(pred_y) / np.log(2))  # measured in mean bits

    ### This is the literal accuracy - it gets complicated
    # Sort the answers by probability, descending (only getting the indices)
    confidence_order = np.argsort(pred)
    # This indexing trick always takes the last assignment for each index
    # This will hold the index of the best answer for each question
    best_answer = np.zeros(np.max(q.astype(int))+1)
    best_answer[q[confidence_order].astype(int)] = confidence_order
    # Take the average correctness of the best answer
    accu_by_q = y[border:][best_answer.astype(int)].mean()

    return [C, gamma, accu, mean_bits, accu_by_q, train_time, test_time]

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
class SVMPredictor(object):
    """"
    A simple application of SVM classifier

    @author: Shaun
    """

    def __init__(self):
        self.clf = SVC(probability=True)

    @abstractmethod
    def fit(self, X, y):
        """
        Method to fit the model.

        Parameters:
        X - 2d numpy array of training data
        y - 1d numpy array of training labels
        """
        self.clf = self.clf.fit(X, y)

    @abstractmethod
    def predict(self, X):
        """
        Method to apply the model data

        Parameters:
        X - 2d numpy array of test data
        """
        return self.clf.predict_proba(X)[:, 1]

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def svcmodel(d,X_2,y_2,X_3,y_3,X_test,y_test):
    X_3_copy = X_3.copy(deep=True)
    X_3_copy['chance']=0
    index = 0    
    
########## k折交叉验证 ###########################
    scores = cross_val_score(SVC(), X_2, y_2, cv=5, scoring='accuracy')
    score_mean =scores.mean()
    print(d+'5折交互检验:'+str(score_mean))
#################################################
    
    svc = SVC(probability=True).fit(X_2,y_2)

################ 预测测试集 ################   
    answer_svc = svc.predict(X_test)
    accuracy = metrics.accuracy_score(y_test,answer_svc)
    print(d+'预测:'+str(accuracy))
###############################################
    
    chance = svc.predict_proba(X_3)[:,1]
    for c in chance:
        X_3_copy.iloc[index,len(X_3_copy.columns)-1]=c
        index += 1
    chance_que = X_3_copy.iloc[:,len(X_3_copy.columns)-1]
    return chance_que

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
def predict_svc(X_train, y_train, X_test, sample_weight):
    clf = SVC(degree=3, gamma=0.0,
              kernel='rbf', probability=True)
    clf.fit(X_train, y_train, sample_weight=sample_weight)

    predictions = clf.predict_proba(X_test)
    return predictions

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import predict_proba [as 别名]
	 def test(self):
                 X, y = self.dataMat,self.labelMat
                 X_test = self.testData
                 clf = SVC(kernel='linear', C= 0.001, probability=True)
                 clf.fit(X, y);
                 y_pred = clf.predict(X_test[1,:]);
                 y_predprob = clf.predict_proba(X_test[1,:]);