def main(model): qa = None if model == 'lstm': import lstm qa = lstm.LSTM() else: import svm qa = svm.SVM() if qa == None: qa = svm.SVM() qa.train_save()
def __init__(self, fakeways=[], arp_for_unknowns=False, wide=False): # These are "fake gateways" -- we'll answer ARPs for them with MAC # of the switch they're connected to. self.fakeways = set(fakeways) self.startTime = time.time() self.svm = svm.SVM() # If True, we create "wide" matches. Otherwise, we create "narrow" # (exact) matches. self.wide = wide # If this is true and we see a packet for an unknown # host, we'll ARP for it. self.arp_for_unknowns = arp_for_unknowns # (dpid,IP) -> expire_time # We use this to keep from spamming ARPs self.outstanding_arps = {} # (dpid,IP) -> [(expire_time,buffer_id,in_port), ...] # These are buffers we've gotten at this datapath for this IP which # we can't deliver because we don't know where they go. self.lost_buffers = {} # For each switch, we map IP addresses to Entries self.arpTable = {} # This timer handles expiring stuff self._expire_timer = Timer(5, self._handle_expiration, recurring=True) core.listen_to_dependencies(self)
def getHumanDetector(winSize): svm4human = svm.SVM() svm4human.setLinearSVM() detector4human = detector.Detector(winSize) detector4human.setClassifier(svm4human) dataSet = [] labels = [] # positive samples posSamples = imageProcessor.loadImages(IN_CLASS_HUMAN_SET_TRAIN) dataSet += posSamples labels += [1 for i in range(len(posSamples))] posSamples = imageProcessor.loadImages(MIT_HUMAN_SET) dataSet += posSamples labels += [1 for i in range(len(posSamples))] # negative samples negSamples = imageProcessor.loadImages(IN_CLASS_BACKGROUND_SET) dataSet += negSamples labels += [0 for i in range(len(negSamples))] # negSamples = imageProcessor.loadImages(IN_CLASS_CAR_SET_TEST) # dataSet += negSamples # labels += [0 for i in range(len(negSamples))] detector4human.train(dataSet, labels) return detector4human
def main(): namer = lambda name: name + '.norm' normalize(('data/spambase.data', ), namer, delimiter=",") data, labels = load_data(('data/spambase.data.norm', ), delimiter=",", label_map={ 0.0: -1.0, 1.0: 1.0 }) indices = range(len(data)) shuffle(indices) train_errors = [] test_errors = [] step = len(data) / NUM_FOLDS for k in range(NUM_FOLDS): train_indices = indices[0:k * step] + indices[(k + 1) * step:-1] test_indices = indices[k * step:(k + 1) * step] learner = svm.SVM(data=data[train_indices], labels=labels[train_indices], tolerance=0.01, epsilon=0.001, cost=0.75, kernel=svm.linear_kernel) learner.train() train_error = learner.test(data[train_indices], labels[train_indices]) test_error = learner.test(data[test_indices], labels[test_indices]) train_errors.append(train_error) test_errors.append(test_error) print "fold %d: train_error=%.6f test_error=%.6f" % ( k + 1, train_error, test_error) train_error = sum(train_errors) / float(NUM_FOLDS) test_error = sum(test_errors) / float(NUM_FOLDS) print "average: train_error=%.6f test_error=%.6f" % (train_error, test_error)
def medium_mouse_click(event): if (event.y >= TOP and event.y <= ORIGEN[1] and event.x >= ORIGEN[0]): canvas = event.widget color = '' flag = False pointX = float(event.x - ORIGEN[0]) / DESPL_X pointY = float(ORIGEN[1] - event.y) / DESPL_Y xx, yy = svm.concatPoints(red_points, blue_points) alfa, w, b, S = svm.SVM(xx, yy) e = svm.verifyPoint(xx, yy, alfa, b, [pointX, pointY]) print e if (e <= 0.0): color = "red" if (e >= -1.0): flag = True else: color = "blue" if (e <= 1.0): flag = True canvas.create_oval(event.x - POINT_RADIO, event.y - POINT_RADIO, event.x + POINT_RADIO, event.y + POINT_RADIO, fill=color, width=1) if (color == "red"): red_points.append((pointX, pointY)) elif (color == "blue"): blue_points.append((pointX, pointY)) if (flag == True): svmAction()
def rescale(Clist = [0.1, 1, 10, 100], data = None, **args) : chain = composite.Chain([preproc.Rescale(), svm.SVM(**args)]) if Clist is not None : param = modelSelection.Param(chain, 'classifier.C', Clist) return modelSelection.ModelSelector(param) else : return chain
def svm(self): svr = svm.SVM("train.csv") clf = svr.train_with_features([0, 1]) print clf if self.p_flag == "p": print svr.predict predictions = clf.predict(svr.predict) self.binning(svr.predict_original, predictions)
def gaussianSelect(gammaList = [0.01, 0.05, 0.1, 0.3, 1, 2], **args) : measure = 'balancedSuccessRate' if 'measure' in args : measure = args['measure'] k = ker.Gaussian() param = modelSelection.Param(svm.SVM(k), 'kernel.gamma', gammaList) return modelSelection.ModelSelector(param, measure = measure)
def svmAction(): tempRed = deepcopy(red_points) tempBlue = deepcopy(blue_points) resetCanvas() copyPoints(tempRed, tempBlue) plotPoints() x, y = svm.concatPoints(red_points, blue_points) alfa, w, b, S = svm.SVM(x, y) plotSVM(w, b, S)
def main(): # create some random rectangles print "Generating rectangles..." rectangles = [] for x in range(0, 24): for y in range(0, 24): for width in range(5, 14): for height in range(5, 14): area = width * height if area >= 130 and area <= 170 \ and x + width <= 28 and y + height <= 28: top_left = (x, y) bottom_right = (x + width, y + height) rectangles.append((top_left, bottom_right)) rectangles = sample(rectangles, 100) # prepare the training data print "Loading images..." images, labels = load_mnist(dataset="training", path="data") print "Preparing training data..." train_indices = sample(range(len(images)), len(images) / 10) train_data = prep_data(images[train_indices], rectangles) train_labels = labels[train_indices].reshape(len(train_indices)) # train learners print "Training..." learners = {} for pair in combinations(range(10), 2): digit_1, digit_2 = pair indices = np.where((train_labels == digit_1) | (train_labels == digit_2))[0] data = train_data[indices] labels = train_labels[indices].copy() labels[labels == digit_1] = -1 labels[labels == digit_2] = 1 learners[pair] = learner = svm.SVM(data=data, labels=labels, tolerance=0.001, epsilon=0.001, cost=0.75, kernel=svm.linear_kernel) learner.train() # prepare the testing data print "Preparing testing data..." images, labels = load_mnist(dataset="testing", path="data") test_indices = list(set(range(len(images))) - set(train_indices)) test_data = prep_data(images[test_indices], rectangles) test_labels = labels[test_indices].reshape(len(test_indices)) # test the learners print "Testing..." train_error = test(learners, train_data, train_labels) test_error = test(learners, test_data, test_labels) print "train_error=%.6f test_error=%.6f" % (train_error, test_error)
def rescaleGaussian(gammaList = [0.01, 0.05, 0.1, 0.3, 1, 2], data = None, **args) : k = ker.Gaussian() s=svm.SVM(k) chain = composite.Chain([preproc.Rescale(), s]) if gammaList is not None : param = modelSelection.Param(chain, 'classifier.kernel.gamma', gammaList) return modelSelection.ModelSelector(param) else : return chain
def custom_SVM_test_function(X_train, y_train, X_test): data_dict = dataset_reader.build_data_dict(X_train, y_train) svm = custom_svm.SVM(data=data_dict, kernel=Kernel.linear(), c=1) svm.fit() y_pred = [] print(X_test[0]) for x in X_test: y_pred.append(svm.predict(x)) return y_pred
def __init__(self, k_max, Cs, weights): """ Initializes the class. k_max is the maximum k_spectrum kernel to consider. Cs is the array of regulizer parametters to use for each kernel. The are averaged. weights are the weights to use in the combiaison. """ def kernel(X, Y): ret = weights[2] * spectrum.k_spectrum(X, Y, k=2) for i in range(3, k_max+1): ret += weights[i] * spectrum.k_spectrum(X, Y, k=i) return ret clf = svm.SVM(kernel=kernel, C=np.mean(Cs)) self.clf = clf
def main(): iris_data = datasets.load_iris() train = iris_data["data"][:100] target = iris_data["target"][:100] f1_scores = np.array([]) for train_index, test_index in StratifiedKFold(n_splits=5, shuffle=True).split(train, target): X_train, X_test = train[train_index], train[test_index] y_train, y_test = target[train_index], target[test_index] model = svm.SVM() model.fit(X_train, y_train) predict = model.predict(X_test) f1_scores = np.append(f1_scores, calc_F1(predict, y_test)) print("F-measure : ", f1_scores) print("F-measure average : ", f1_scores.mean())
def fit(self,X,y,gamma=1,landmarks=None,learning_rate=1,epochs=1000,C=1): ''' Fits the data to the SVM using an rbf kernel gamma (1/sigma**2) can be speficied by user (default=1) the number of landmarks can also be specified by user (default is len(X)) if the number of landmarks is specified, the landmarks are randomly chosen from X Other parameters for the SVM can also be specified here (and are passed to the linear SVM) ''' self.gamma = gamma # remove row on constants 1 if present (saves memory and a tiny bit of time) if (X[0,0]==1 and len(np.unique(X[:,0]))==1): X = X[:,1:] # generate and store landmarks if (landmarks==None or landmarks>=len(X)): self.landmarks = X else: self.landmarks = X[np.random.choice(np.arange(len(X),dtype=int),landmarks,replace=False)] # generate matrix of features X = self.transform(X) # fit to a linear SVM self.svm = svm.SVM() # no x0 appears to perform better self.svm.fit(X, y, learning_rate, epochs,C,add_x0=False)
def run(X, y, train_rate, kernel, C, max_iter, gama): f_log.write("this is para{train_set_rate:" + str(train_rate) + " kernel:" + str(kernel) + " C:" + str(C) + " max_iter:" + str(max_iter) + " gama:" + str(gama) + "}" + "\n") n = len(X) xx = int(n * train_rate) train_X_set = X[:xx] train_y_set = y[:xx] test_X_set = X[xx:] test_y_set = y[xx:] svm_Model = svm.SVM(kernel, C) svm_Model.set_gama(gama) alpha, b = svm_Model.train(train_X_set, train_y_set, max_iter) f_log.write("alpha:" + str(alpha) + "\n") f_log.write("b:" + str(b) + "\n") f_log.write("train_rate:" + str(train_rate) + "\n") if kernel == 'linear': w = np.dot(train_X_set.T, np.multiply(alpha, train_y_set)) np.save('./linear_w.npy', w) np.save('./linear_b.npy', b) else: np.save('./rbf_alpha.npy', alpha) np.save('./rbf_b.npy', b) predictor = svm.Predictor(kernel, alpha, b, train_y_set, train_X_set, gama)
import matplotlib.pyplot as plt import pandas as pd import utils # learner imports import svm import knn #Main Script Run #This script will show as an example of the use of a KNN and SVM learners #Created by Elijah Flinders #svm setup and training print("*********************************************************************") print("Creating and testing SVM on it's own dataset. Support Vector Machine") print("*********************************************************************") svm = svm.SVM(10000, 0.000001) svm.fit() print("Finished running the SVM!\n") #KNN setup and prediction print("************************************************") print("Creating and testing KNN. K-th Nearest Neighbor") print("************************************************") knnTester = knn.KNN() # load the Iris data set and convert to specific type dataset = knnTester.loadCsvListKnn('iris.csv') for i in range(len(dataset[0]) - 1): knnTester.colToFloat(dataset, i) # convert columns to ints
best_batch = minibatch[m] best_alpha = alpha[a] print("When batch size is {0}, alpha is {1}, test error is {2}".format( best_batch, best_alpha, utils.classification_error(model.predict(Xtest), ytest))) elif Model == 'svm': # standardize X X, mu, sigma = utils.standardize_cols(X) Xvalid, _, _ = utils.standardize_cols(Xvalid, mu, sigma) Xtest, _, _ = utils.standardize_cols(Xtest, mu, sigma) # SVM model = svm.SVM() minibatch = [500, 1000, 1500] alpha = [0.01, 0.001, 0.0001] min_val_error = 1 best_batch = 0 best_alpha = 0 for m in range(3): for a in range(3): val_error = [] # cross validation for train, validate in kf.split(X, y): model.fit(X[train], y[train], epoch=100, minibatch=minibatch[m],
def linear(): x1, y1, x2, y2 = get_linear_outlier_training_examples() x = np.vstack((x1, x2)) y = np.hstack((y1, y2)) model = svm.SVM(kernel='linear', C=0.0) model.fit(x, y) for p in x1: plt.scatter(p[0], p[1], c='blue', marker='o', alpha=1, edgecolors='none') for p in x2: plt.scatter(p[0], p[1], c='red', marker='o', alpha=1, edgecolors='none') w, b = model.get_model() print(w) print(b) k = float(-w[0:1, 0:1] / w[0:1, 1:2]) intercept = float(b / w[0:1, 1:2]) print(k, intercept) p1 = [0, 10] p2 = [float(b), k * 10 + intercept] plt.plot(p1, p2, c='black') x1, y1, x2, y2 = get_linear_outlier_test_examples() x = np.vstack((x1, x2)) y = np.hstack((y1, y2)) succ = 0 total = 0 s_set = set() for i in range(x.shape[0]): total += 1 pred = model.predict(x[i]) if pred == y[i]: s_set.add(i) succ += 1 print('accuracy:', succ / total) c = 0 for p in x1: if c in s_set: plt.scatter(p[0], p[1], c='blue', marker='^', alpha=1, edgecolors='none') else: plt.scatter(p[0], p[1], c='black', marker='^', alpha=1, edgecolors='none') c += 1 for p in x2: if c in s_set: plt.scatter(p[0], p[1], c='red', marker='^', alpha=1, edgecolors='none') else: plt.scatter(p[0], p[1], c='black', marker='^', alpha=1, edgecolors='none') c += 1 plt.grid(True) plt.show(block=True)
import svm import pandas as pd from sklearn import datasets from sklearn import preprocessing from sklearn import metrics from sklearn.model_selection import train_test_split if __name__ == '__main__': train_df = pd.read_csv("sprint4/wdbc.data", header=None) y = train_df[1] X = train_df.drop([0, 1], axis=1) scaler = preprocessing.StandardScaler() X_std = scaler.fit_transform(X) y = list(map(lambda l: 1 if l == 'M' else -1, y)) X_train , X_test , y_train , y_test =\ train_test_split(X_std, y, test_size=0.2, random_state=0) # ラベルは1, -1 # スケーリング clf = svm.SVM() clf.fit(X_train, y_train) y_pred = clf.predict(X_test) print("Confusion Matrix") print(metrics.confusion_matrix(y_test, y_pred)) print(metrics.classification_report(y_test, y_pred))
train_data = data[:train_len] train_tar = target[:train_len] valid_data = data[train_len:train_len + valid_len] valid_tar = target[train_len:train_len + valid_len] test_data = data[train_len + valid_len:] test_tar = target[train_len + valid_len:] data = { 'X_train': train_data, # training data 'y_train': train_tar, # training labels 'X_val': valid_data, # validation data 'y_val': valid_tar # validation labels } model = svm.SVM(input_dim=D, hidden_dim=200, reg=0.005) solver = solver.Solver(model, data, update_rule='adam', optim_config={ 'learning_rate': 1e-3, }, lr_decay=1, num_epochs=3000, batch_size=500, print_every=1) solver.train() acc = solver.check_accuracy(test_data, test_tar)
def polynomial(): x1, y1, x2, y2 = get_polynomial_training_examples() x = np.vstack((x1, x2)) y = np.hstack((y1, y2)) model = svm.SVM(kernel='polynomial', C=0.0) model.fit(x, y) for p in x1: plt.scatter(p[0], p[1], c='blue', marker='o', alpha=1, edgecolors='none') for p in x2: plt.scatter(p[0], p[1], c='red', marker='o', alpha=1, edgecolors='none') w, b = model.get_model() print(w) print(b) x1, y1, x2, y2 = get_polynomial_test_examples() x = np.vstack((x1, x2)) y = np.hstack((y1, y2)) succ = 0 total = 0 s_set = set() for i in range(x.shape[0]): total += 1 pred = model.predict(x[i]) if pred == y[i]: s_set.add(i) succ += 1 print('accuracy:', succ / total) c = 0 for p in x1: if c in s_set: plt.scatter(p[0], p[1], c='blue', marker='^', alpha=1, edgecolors='none') else: plt.scatter(p[0], p[1], c='black', marker='^', alpha=1, edgecolors='none') c += 1 for p in x2: if c in s_set: plt.scatter(p[0], p[1], c='red', marker='^', alpha=1, edgecolors='none') else: plt.scatter(p[0], p[1], c='black', marker='^', alpha=1, edgecolors='none') c += 1 plt.grid(True) plt.show(block=True)
fig.add_trace( go.Scatter3d(x=data_reduced.T[0][i:i + 100], y=data_reduced.T[1][i:i + 100], z=data_reduced.T[2][i:i + 100], mode='markers', marker=dict(size=3))) fig.show() ##################################################### # Classify ##################################################### print('\nAttempt: Classification...') # Init classifier classifier = svm.SVM() # Fit to training data W = classifier.learn(data_reduced, y_train) if (params['resub']): # Classify on resub classifier.predict(data_reduced, y_train) else: # Classify on test data # Smush features together features_ravel = np.empty((1, 2048)) for feat in test_features: features_ravel = np.append(features_ravel, feat, axis=0) features_ravel = features_ravel[1:]
import pandas as pd import scipy.io as spy import matplotlib.pyplot as plt import matplotlib.colors as mplcolors import numpy as np import svm if __name__ == "__main__": data = spy.loadmat('ressources/ex6data1.mat') X = np.array(data['X']) print(X.mean(axis=0), X[:, 1].mean()) print(X.std(axis=0)) labels = np.array(data['y']) labels[labels == 0] = -1 print('lab ', labels.shape) y = ['red' if i == 1 else 'blue' for i in labels] colors = ['red', 'blue'] plt.scatter(x=X[:, 0], y=X[:, 1], c=y) plt.show() my_svm = svm.SVM(learn_rate=0.01, reg_param=0.03, epoch=1000) my_svm.fit(X, labels, normalize=True) my_svm.run_svm() print(my_svm.get_prediction(X, labels))
def rbf(): x1, y1, x2, y2 = get_rbf_training_examples() x = np.vstack((x1, x2)) y = np.hstack((y1, y2)) model = svm.SVM(kernel='rbf', C=0.0) model.fit(x, y) fig = plt.figure() ax = fig.add_subplot(111) circle = Circle(xy=(0.0, 0.0), radius=5, alpha=0.3) ax.add_patch(circle) for p in x1: plt.scatter(p[0], p[1], c='blue', marker='o', alpha=1, edgecolors='none') for p in x2: plt.scatter(p[0], p[1], c='red', marker='o', alpha=1, edgecolors='none') w, b = model.get_model() print(w) print(b) x1, y1, x2, y2 = get_rbf_test_examples() x = np.vstack((x1, x2)) y = np.hstack((y1, y2)) succ = 0 total = 0 s_set = set() for i in range(x.shape[0]): total += 1 pred = model.predict(x[i]) if pred == y[i]: s_set.add(i) succ += 1 print('accuracy:', succ / total) c = 0 for p in x1: if c in s_set: plt.scatter(p[0], p[1], c='blue', marker='^', alpha=1, edgecolors='none') else: plt.scatter(p[0], p[1], c='black', marker='^', alpha=1, edgecolors='none') c += 1 for p in x2: if c in s_set: plt.scatter(p[0], p[1], c='red', marker='^', alpha=1, edgecolors='none') else: plt.scatter(p[0], p[1], c='black', marker='^', alpha=1, edgecolors='none') c += 1 plt.grid(True) plt.show(block=True)
inst_logR.begin_alg() param_classif = inst_logR.get_param() #print param_classif inst_dtree = decisiontreeNoZScoreKBest.DecisionTree(data_reader.copy(), class_values) print """ ---------------- """ print("Decision Tree Classifier algorithm...") inst_dtree.begin_alg() param_classif = inst_dtree.get_param() #print param_classif inst_svm = svm.SVM(data_reader.copy(), class_values) print """ ---------------- """ print("Support Vector Machines(SVM) algorithm...") inst_svm.begin_alg() param_weight = inst_svm.get_param() #print param_classif print """ ------- testing data...ZeroR ------- """
import cv2 import data import hog import svm as SupportVectorMachine import objectdetector as od import evaluate import pickle import math train_data, train_data_mirrored, train_labels = data.get_train_data() svm = SupportVectorMachine.SVM("trained_svm.data") if not svm.isTrained: svm.train(train_data, train_labels) mirrored_svm = SupportVectorMachine.SVM("trained_mirrored_svm.data") if not mirrored_svm.isTrained: mirrored_svm.train(train_data_mirrored, train_labels) hog = hog.HOGDescriptor() objectDetector = od.ObjectDetector(scales=10, scaling=0.8, stride=(6, 5), detection_threshold=0.6, overlap_threshold=0.5) while True: command = input("\nType a command\n") arguments = command.split()
def extract(data, cl=1): x = [] y = [] for d in data: if d.val == cl: x.append(d.x) y.append(d.y) return x, y linData = dr.readData('linsep.txt') print(linData) linsvm = svm.SVM(linData) w, b = linsvm.train() print(w) print(b) correctRate = linsvm.test(linData) print('percent correct') print(correctRate) px, py = extract(linData, +1) nx, ny = extract(linData, -1) lx = np.linspace(0, .6, 100) ly = [] for x in lx:
__author__ = 'yujinke' import numpy as np import cv2 import matplotlib as plt import svm import os import cPickle dir_T = "./Char_classify/T" dir_F = "./Char_classify/F" dir_folder = "./HasPlate" model = svm.SVM(C=1.67, gamma=0.0383) model.load('digits_svm.dat') # f = open("./data.pkl", 'rb') # training_data, validation_data, test_data = cPickle.load(f) # samples_train, labels_train= test_data # # for i in range(100): # # print "result",model.predict_single(samples_train[i]),labels_train[i] # samples_train[i]= samples_train[i]*255 # # P = samples_train[i].astype(np.uint8) # # P =P.reshape((28,28)) #
def main(): qa = svm.SVM() qa.train_save() sent = '澳大利亚 是 南半球 面积 第 几 大 的 国家' print(extract_word(sent)) qa.forward(sent)