def __init__(self, datadir, crop=None, transform=None):
self.datadir = datadir
self.crop = crop #has form of tuple of ((y,x),(height, width))
self.transform = transform #has form of np.mat with shape (2,2)
self.haar_cascade = cv2.CascadeClassifier(
os.path.join(datadir, 'haarcascade_russian_plate_number.xml'))
self.letter_svm = {}
for letter in [
'0O', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
'C', 'E', 'H', 'K', 'M', 'P', 'T', 'X', 'Y', '8dot', 'dotH',
'dotM', 'dotO', 'dotE', 'dotC', 'dotP', 'dotB'
]:
svm_file = os.path.join(datadir,
'svm_letter_' + letter + '_stage_1.xml')
self.letter_svm[letter] = cv2.SVM()
self.letter_svm[letter].load(svm_file)
svm_file = os.path.join(datadir, 'svm_left_border.xml')
self.left_border = cv2.SVM()
self.left_border.load(svm_file)
svm_file = os.path.join(datadir, 'svm_right_border.xml')
self.right_border = cv2.SVM()
self.right_border.load(svm_file)
svm_file = os.path.join(datadir, 'svm_plate.xml')
self.plate_svm = cv2.SVM()
self.plate_svm.load(svm_file)
svm_file = os.path.join(datadir, 'svm_vertical_stage1.xml')
self.vertical_stage1_svm = cv2.SVM()
self.vertical_stage1_svm.load(svm_file)
def __init__(self, num_classes, mode="one-vs-all", params=None):
"""
The constructor makes sure the correct number of classifiers is
initialized, depending on the mode ("one-vs-all" or "one-vs-one").
:param num_classes: The number of classes in the data.
:param mode: Which classification mode to use.
"one-vs-all": single classifier per class
"one-vs-one": single classifier per class pair
Default: "one-vs-all"
:param params: SVM training parameters.
For now, default values are used for all SVMs.
Hyperparameter exploration can be achieved by
embedding the MultiClassSVM process flow in a
for-loop that classifies the data with
different parameter values, then pick the
values that yield the best accuracy.
Default: None
"""
self.num_classes = num_classes
self.mode = mode
self.params = params or dict()
# initialize correct number of classifiers
self.classifiers = []
if mode == "one-vs-one":
# k classes: need k*(k-1)/2 classifiers
for _ in xrange(num_classes * (num_classes - 1) / 2):
self.classifiers.append(cv2.SVM())
elif mode == "one-vs-all":
# k classes: need k classifiers
for _ in xrange(num_classes):
self.classifiers.append(cv2.SVM())
else:
print "Unknown mode ", mode
def predict_shape(path, val):
training_set = []
test_set = []
test_set1 = []
color_test_set = []
training_labels = []
result_list = []
###### SVM training ########################
svm = cv2.SVM()
svm.load('hog_svm_data1.dat')
svm1 = cv2.SVM()
svm1.load('hog_svm_data2.dat')
###### Now testing HOG ########################
img = cv2.imread(path)
res = cv2.resize(img, (400, 300))
h = hog(res)
test_set.append(h)
testData = np.float32(test_set)
pre_shape = svm.predict(testData)
if val == 3:
if pre_shape == 2:
img = cv2.imread(path)
res = cv2.resize(img, (400, 300))
h = hog(res)
test_set1.append(h)
testData = np.float32(test_set1)
pre_shape = svm1.predict(testData)
print 'inside'
return pre_shape
return pre_shape
def trainSVM(input_, response_):
logger.info('...training SVM')
svmParams = dict(kernel_type = cv2.SVM_RBF, svm_type = cv2.SVM_C_SVC, term_crit=(cv2.TERM_CRITERIA_COUNT | cv2.TERM_CRITERIA_EPS, 10000, 0.0000000001))
svm_auto = cv2.SVM()
svm_auto.train_auto(input_, response_, None, None, params=svmParams, k_fold=7)
svmParams['C'] = 100
svmParams['gamma'] = 2
svm = cv2.SVM()
svm.train(input_, response_, params=svmParams)
return [svm, svm_auto]
def test_472(self):
# 47.2使用SVM进行手写数据OCR
SZ = 20
bin_n = 16 # Number of bins
svm_params = dict(kernel_type=cv2.SVM_LINEAR,
svm_type=cv2.SVM_C_SVC,
C=2.67,
gamma=5.383)
affine_flags = cv2.WARP_INVERSE_MAP | cv2.INTER_LINEAR
img = cv2.imread('digits.png', 0)
cells = [np.hsplit(row, 100) for row in np.vsplit(img, 50)]
# First half is trainData, remaining is testData
train_cells = [i[:50] for i in cells]
test_cells = [i[50:] for i in cells]
###### Now training ########################
deskewed = [map(deskew, row) for row in train_cells]
hogdata = [map(hog, row) for row in deskewed]
trainData = np.float32(hogdata).reshape(-1, 64)
responses = np.float32(np.repeat(np.arange(10), 250)[:, np.newaxis])
svm = cv2.SVM()
svm.train(trainData, responses, params=svm_params)
svm.save('svm_data.dat')
###### Now testing ########################
deskewed = [map(deskew, row) for row in test_cells]
hogdata = [map(hog, row) for row in deskewed]
testData = np.float32(hogdata).reshape(-1, bin_n * 4)
result = svm.predict_all(testData)
####### Check Accuracy ########################
mask = result == responses
correct = np.count_nonzero(mask)
print("")
def predict_color(path):
training_set = []
test_set = []
color_test_set = []
training_labels = []
result_list = []
###### Now testing Color ########################
svm1 = cv2.SVM()
svm1.load('color_svm_data.dat')
img = cv2.imread(path)
res = cv2.resize(img, (400, 300))
crop_img = res[50:150, 100:200]
cv2.imwrite("d:/Emmanu/project-data/color-test.jpg", crop_img)
img = Image.open('d:/Emmanu/project-data/color-test.jpg')
img200 = img.convert('RGBA')
arr = np.array(img200)
flat_arr = arr.ravel()
color_test_set.append(flat_arr)
testData = np.float32(color_test_set)
pre_color = svm1.predict(testData)
return pre_color
def train_classifier(svm_data_dir):
with open(os.path.join(svm_data_dir, "training_data")) as f:
training_data = np.load(f)
with open(os.path.join(svm_data_dir, "training_labels")) as f:
training_labels = np.load(f)
with open(os.path.join(svm_data_dir, "testing_data")) as f:
testing_data = np.load(f)
with open(os.path.join(svm_data_dir, "testing_labels")) as f:
testing_labels = np.load(f)
svm = cv2.SVM()
svm_params = dict(kernel_type=cv2.SVM_LINEAR, svm_type=cv2.SVM_C_SVC)
svm.train_auto(training_data,
training_labels,
None,
None,
params=svm_params,
k_fold=50)
svm.save(os.path.join(svm_data_dir, 'svm_data.dat'))
results = svm.predict_all(testing_data)
mask = results == testing_labels.reshape((-1, 1))
correct = np.count_nonzero(mask)
print correct * 100.0 / results.size
def load_svm(svm_file, x, y, svm_par):
"""Loads the SVM module"""
if os.path.isfile(svm_file):
svm_vec = pickle.load(open(svm_file))
else:
svm_obj = cv2.SVM()
svm_obj.train_auto(x,
y,
None,
None,
params=svm_par,
k_fold=5,
balanced=True)
# svm_obj.train(x, y, None, None, params=svm_par)
svm_obj.save("svm.xml")
tree = Et.parse('svm.xml')
root = tree.getroot()
sup_vec = root.getchildren()[0].getchildren()[-2].getchildren()[0]
rho = float(root.getchildren()[0].getchildren()[-1].getchildren()
[0].getchildren()[1].text)
svm_vec = [
float(x)
for x in re.sub('\s+', ' ', sup_vec.text).strip().split(' ')
]
svm_vec.append(-rho)
pickle.dump(svm_vec, open(svm_file, 'w'))
return svm_vec
def main():
for vertorNum in range(1, 201):
xTrain_, yTrain, xTest_, yTest = loadImageSet()
num_train, num_test = xTrain_.shape[0], xTest_.shape[0]
xTrain_, yTrain, xTest_, yTest = loadImageSet()
num_train, num_test = xTrain_.shape[0], xTest_.shape[0]
xTrain, data_mean, V = pca(xTrain_, vertorNum)
xTest = np.array(
(xTest_ - np.tile(data_mean, (num_test, 1))) * V) # 得到测试脸在特征向量下的数据
# yPredict = [yTrain[np.sum((xTrain - np.tile(d, (num_train, 1))) ** 2, 1).argmin()] for d in xTest]
# print u'欧式距离法识别率: %.2f%%' % ((yPredict == yTest).mean() * 100)
svm = cv2.SVM()
svm.train(np.float32(xTrain),
np.float32(yTrain),
params={'kernel_type': cv2.SVM_LINEAR})
yPredict = [svm.predict(d) for d in np.float32(xTest)]
# yPredict = svm.predict_all(xTest.astype(np.float64))
# average = 0
# for index in range(1,11):
# average += ((yPredict == yTest).mean() * 100)
# if(index == 10 ):
# print '%d' % (vertorNum) + u' ： 支持向量机识别率: %.2f%% \n' % (average/10)
# # print '%d' % (vertorNum) + u' %.2f%% \n' % (average / 10)
print "选择的特征值的个数：%d" % vertorNum
print "准确度：%.2f%%" % ((yPredict == yTest).mean() * 100)
print "测试的具体情况"
for index, item in enumerate(yPredict):
print index / 5, item, index / 5 == item
print '\n'
def __init__(self, trainName, testName, save = 0):
self.save = save
self.trainName = trainName
self.testName = testName
self.trainData = np.empty(shape = [0, 3])
self.testData = self.trainData.copy()
self.svm = cv2.SVM()
def teamMain():
DIR = '/home/archer/Documents/maxent/data/basketball/leaguerank/'
teamIds = loadTeamIds(DIR + 'teamidshortname.csv')
teamNames = [x[1] for x in loadMatrixFromFile(DIR + 'teamidshortname.csv')]
countTotal = 0
total = 0
for team in teamIds:
trainData = buildTrainingSets(DIR + team + '-train.csv.knn')
trainLabels = buildTrainingLabels(DIR + team + '-train.csv.knn')
testData = buildTestingSets(DIR + team + '-test.csv.knn')
testLabels = buildTestingLabels(DIR + team + '-test.csv.knn')
total = total + len(testLabels)
svm = cv2.SVM()
svm.train(trainData, trainLabels, params=svm_params)
svm.save('svm_data.dat')
# Accuracy
count = 0
for i in range(len(testLabels)):
ret = svm.predict(np.array([testData[i]]))
if ret == testLabels[i][0]:
count = count + 1
countTotal = countTotal + count
print 'INFO: Accuracy(', team, ')', count / float(len(testLabels))
print 'INFO: Total Accuracy: ', countTotal / float(total)
def inflate_classifier(classifier_root_dir):
vocab_path, unlabelled_dir, labelled_dir, features_dir, svm_data_dir = \
get_classifier_directories(classifier_root_dir)
with open(vocab_path, "rb") as f:
vocab = np.load(f)
# FLANN parameters
flann_index_kdtree = 0
index_params = dict(algorithm=flann_index_kdtree, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
matcher = cv2.FlannBasedMatcher(index_params, search_params)
detector = cv2.SIFT()
extractor = cv2.DescriptorExtractor_create("SIFT")
bow_de = cv2.BOWImgDescriptorExtractor(extractor, matcher)
bow_de.setVocabulary(vocab)
svm = cv2.SVM()
svm.load(os.path.join(svm_data_dir, "svm_data.dat"))
def classifier(image):
keypoints = detector.detect(image)
descriptor = bow_de.compute(image, keypoints)
return svm.predict(descriptor)
return classifier
def seasonMain():
DIR = '/home/archer/Documents/maxent/data/basketball/leaguerank/'
seasons = loadSeasons(DIR + 'seasons-18-Nov-2014.txt')
countTotal = 0
total = 0
for season in seasons:
trainData = buildTrainingSets(DIR + season + '-train.csv.knn')
testData = buildTestingSets(DIR + season + '-test.csv.knn')
trainLabels = buildTestingLabels(DIR + season + '-train.csv.knn')
testLabels = buildTestingLabels(DIR + season + '-test.csv.knn')
total = total + len(testLabels)
svm = cv2.SVM()
svm.train(trainData, trainLabels, params=svm_params)
svm.save('svm_data.dat')
# Accuracy
count = 0
for i in range(len(testLabels)):
ret = svm.predict(np.array([testData[i]]))
if ret == testLabels[i][0]:
count = count + 1
countTotal = countTotal + count
print 'INFO: Accuracy(', season, ')', count / float(len(testLabels))
print 'INFO: Total Accuracy: ', countTotal / float(total)
def TrainNSaveSVM(TrainingData, LabelData, SvmDataFileName='svm_data.dat'):
''' Trains and saves SVM into (.dat) file. Pass None in Filename to avoid saving.'''
svm_params = dict(kernel_type=cv2.SVM_LINEAR, svm_type=cv2.SVM_C_SVC)
svm = cv2.SVM()
svm.train(TrainingData, LabelData, params=svm_params)
if SvmDataFileName: # if None, do not save
svm.save(SvmDataFileName)
def trainInMyWay(target, labels):
# First half is trainData, remaining is testData
train_cells = target
###### Now training ########################
deskewed = [map(deskew, row) for row in train_cells]
hogdata = [map(hog, row) for row in deskewed]
trainData = np.float32(train_cells).reshape(-1, 64)
print(trainData.shape)
#response is array of n * 1, i.e. [[1],[2],[3]...]
responses = np.float32(labels)[:, np.newaxis]
svm = cv2.SVM()
svm.train(trainData, responses, params=svm_params)
#svm.save('svm_data.dat')
###### Now testing ########################
testData = trainData
result = svm.predict_all(testData)
####### Check Accuracy ########################
mask = result == responses
#for c in result:
# print(chr(c + ord('A')))
mask = mask.astype(np.uint8)
#print(mask)
correct = np.count_nonzero(mask)
#print(correct)
print(correct * 100.0 / result.size)
def testing():
svm_model = cv2.SVM()
svm_model.load('svm_data.dat')
feature_mat = []
response = []
image_names = []
pix_cm = []
fruit_contours = []
fruit_areas = []
fruit_volumes = []
fruit_mass = []
fruit_calories = []
skin_areas = []
fruit_calories_100grams = []
for j in [1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
for i in range(21,26):
img_path = "../Dataset/images/Test_Images/"+str(j)+"_"+str(i)+".jpg"
print img_path
fea, farea, skinarea, fcont, pix_to_cm = readFeatureImg(img_path)
pix_cm.append(pix_to_cm)
fruit_contours.append(fcont)
fruit_areas.append(farea)
feature_mat.append(fea)
skin_areas.append(skinarea)
response.append([float(j)])
image_names.append(img_path)
testData = np.float32(feature_mat).reshape(-1,94)
responses = np.float32(response)
result = svm_model.predict_all(testData)
mask = result==responses
#calculate calories
for i in range(0, len(result)):
volume = getVolume(result[i], fruit_areas[i], skin_areas[i], pix_cm[i], fruit_contours[i])
mass, cal, cal_100 = getCalorie(result[i], volume)
fruit_volumes.append(volume)
fruit_calories.append(cal)
fruit_calories_100grams.append(cal_100)
fruit_mass.append(mass)
#write into csv file
with open('output.csv', 'w') as outfile:
writer = csv.writer(outfile)
data = ["Image name", "Desired response", "Output label", "Volume (cm^3)", "Mass (grams)", "Calories for food item", "Calories per 100 grams"]
writer.writerow(data)
for i in range(0, len(result)):
if (fruit_volumes[i] == None):
data = [str(image_names[i]), str(responses[i][0]), str(result[i][0]), "--", "--", "--", str(fruit_calories_100grams[i])]
else:
data = [str(image_names[i]), str(responses[i][0]), str(result[i][0]), str(fruit_volumes[i]), str(fruit_mass[i]), str(fruit_calories[i]), str(fruit_calories_100grams[i])]
writer.writerow(data)
outfile.close()
for i in range(0, len(mask)):
if mask[i][0] == False:
print "(Actual Reponse)", responses[i][0], "(Output)", result[i][0], image_names[i]
correct = np.count_nonzero(mask)
print correct*100.0/result.size
def main():
img = cv2.imread('digits.png', 0)
cells = [np.hsplit(row, 100) for row in np.vsplit(img, 50)]
# First half is trainData, remaining is testData
train_cells = [i[:50] for i in cells]
test_cells = [i[50:] for i in cells]
###### Now training ########################
deskewed = [map(deskew, row) for row in train_cells]
hogdata = [map(hog, row) for row in deskewed]
trainData = np.float32(hogdata).reshape(-1, 64)
responses = np.float32(np.repeat(np.arange(10), 250)[:, np.newaxis])
svm = cv2.SVM()
svm.train(trainData, responses, params=svm_params)
svm.save('svm_data.dat')
###### Now testing ########################
deskewed = [map(deskew, row) for row in test_cells]
hogdata = [map(hog, row) for row in deskewed]
testData = np.float32(hogdata).reshape(-1, bin_n * 4)
result = svm.predict_all(testData)
####### Check Accuracy ########################
mask = result == responses
correct = np.count_nonzero(mask)
print(correct * 100.0 / result.size)
def classify():
svm = cv2.SVM()
svm.load("svmV2.clf")
centers = np.load('Temp/voc.npy')
total = 0; correct = 0; dictIdx = 0
dirs = os.listdir(testset_path)
print 'start testing'
print 'classify', dirs
for dir in dirs:
count = 0; crt = 0
files = os.listdir(os.path.join(testset_path, dir))
for f in files:
count += 1
im = cv2.imread(os.path.join(testset_path,dir,f))
des = calcSiftFeature(im)
feature = calcImageFeature(des, centers)
feature = feature*idf
feature = preprocessing.normalize(feature, norm='l2')
if dictIdx == svm.predict(feature):
crt += 1
print 'Accuracy Class', dir, crt, '/', count, '=',float(crt)/count
total += count
correct += crt
dictIdx += 1
print 'Total Accuracy ', correct, '/', total, float(correct)/total
def get_classifier(self, feat, tag):
samples = np.loadtxt(feat, np.float32)
responses = np.loadtxt(tag, np.float32)
responses = responses.reshape((responses.size, 1))
model = cv2.SVM()
model.train(samples, responses)
return model
def main_func():
#grab the image
fileName = getImageName()
grab(fileName)
image = cv2.imread(fileName)
# Need to add in Andres's code to grab an image
coordinates = get_coordinates('coordinates.txt');
positions = get_positions('positions.txt');
crops = get_crops(image, coordinates);
hogData = create_hog(crops);
hogData = hogData.astype(np.float32);
# Initialize SVM
svm = cv2.SVM();
svm.load('svm_data.dat');
result = svm.predict_all(hogData);
spaces_list = [];
for i in range(len(result)):
if (result[i][0] == 1):
spaces_list.append(Spot(positions[i][0], positions[i][1]));
cv2.circle(image, ((coordinates[i][2] + coordinates[i][3])/2, (coordinates[i][0] + coordinates[i][1])/2), 35, (0, 0, 255), 5);
cv2.imwrite('Result.jpg', image);
return spaces_list
def trainsvm(materials):
svm = cv2.SVM()
responses = []
trainData = []
labels = open('label.txt', 'a')
for label, vectors in materials.items():
labelhash = hash(label) % 1000000
labels.write(str(labelhash) + '\t' + str(label))
#inversehash[labelhash] = label
charact = np.float32(vectors).reshape(-1, 64)
for cha in charact:
trainData.append(cha)
for i in range(len(vectors)):
responses.append(labelhash)
trainData = np.array(trainData)
# print "out",trainData
responses = np.float32((np.array(responses))[:, np.newaxis])
# print "reout",responses
# responses = np.float32((responses)[:,np.newaxis] )
# print "responses",responses
svm.train(trainData, responses, params=svm_params)
svm.save('svm_image.dat')
return svm
def train_svm(self, file_name):
'''DOCSTRING:
Given .npz file of training data and labels, initializes, sets
parameters/data for, and trains SVM to distinguish between chars in
provided test data; returns SVM
'''
# Sets parameters of svm to use
svm_params = dict(kernel_type = cv2.SVM_LINEAR, svm_type = \
cv2.SVM_NU_SVC, nu=.105)
# gamma = 5.383
# reads data in .svm file and formats for svm
with np.load(self.PARAMS_PATH + '/params/' + file_name +
'.npz') as input_data:
print('MSG: training data length: ' +
str(len(input_data['train'])))
print('MSG: training data length: ' +
str(len(input_data['train_labels'])))
train_data = input_data['train']
data_labels = input_data['train_labels']
SVM = cv2.SVM()
SVM.train(train_data, data_labels, params=svm_params)
return SVM
def __init__(self, character_width=15, character_height=15, classifier_type="svm_linear"):
self.character_width = character_width
self.character_height = character_height
self.classifier_type = classifier_type
self.resize = 128
if classifier_type == "knn":
self.classifier = cv2.KNearest()
else:
self.classifier = cv2.SVM()
if self.classifier_type == "svm_linear_hog":
winSize = (128,128)
blockSize = (32,32)
blockStride = (16,16)
cellSize = (8,8)
nbins = 9
derivAperture = 1
winSigma = 4.
histogramNormType = 0
L2HysThreshold = 2.0000000000000001e-01
gammaCorrection = 0
nlevels = 32
self.hog = cv2.HOGDescriptor(winSize,blockSize,blockStride,cellSize,nbins,derivAperture,winSigma,
histogramNormType,L2HysThreshold,gammaCorrection,nlevels)
def trainsvm(materials):
svm = cv2.SVM()
# svm.load('svm_image.txt')
re1 = svm.get_support_vector_count()
responses = []
trainData = []
for label, vectors in materials.items():
labelhash = hash(label) % 1000000
inversehash[labelhash] = label
charact = np.float32(vectors).reshape(-1, 64)
for cha in charact:
trainData.append(cha)
for i in range(len(vectors)):
responses.append(labelhash)
trainData = np.array(trainData)
# print "out",trainData
responses = np.float32((np.array(responses))[:, np.newaxis])
# print "reout",responses
# responses = np.float32((responses)[:,np.newaxis] )
# print "responses",responses
svm.train(trainData, responses, params=svm_params)
re2 = svm.get_support_vector_count()
print "re1", re1, "re2", re2
svm.save('svm_face.dat')
return svm
def __init__(self, features, label, C=1, gamma = 0.5,):
####UNCOMMENT TO USE SVM
#self.params = dict(kernel_type=cv2.SVM_LINEAR,
# svm_type=cv2.SVM_C_SVC,
# C=C)
##### random trees parameters
self.params = dict(max_depth=100,
min_sample_count=1,
use_surrogates=False,
max_categories=5,
calc_var_importance=False,
nactive_vars=0,
max_num_of_tree_in_the_forest=100,
term_crit=(cv2.TERM_CRITERIA_MAX_ITER,100,0.1))
#####
self.le = preprocessing.LabelEncoder()
self.le.fit(label)
leLabels = np.array(self.le.transform(label), dtype=np.float32)
features_train, features_test = cross_validation.train_test_split(features, test_size=0.4, random_state=0)
labels_train, labels_test = cross_validation.train_test_split(leLabels, test_size=0.4, random_state=0)
#result = self.training(features_train, labels_train) ### uncomment to use svm
result = self.trainingForest(features_train, labels_train)
self.crossValidation(result, features_test, labels_test)
self.model = cv2.SVM()
def training(self, features, label):
features = np.array(features, dtype=np.float32)
self.model = cv2.SVM()
self.model.train(features, label, params=self.params)
model_dir = settings.MODELS_ROOT
svm_filename = os.path.join(model_dir, "svm.xml")
self.model.save(svm_filename)
def train_svm():
# CV2 SVM
svm_params = dict( kernel_type = cv2.SVM_RBF,
svm_type = cv2.SVM_C_SVC,
C=9.34, gamma=15.68 )
svm=cv2.SVM()
label_list=[]
label_list.append('a')
url='train_images/'
train_set = []
s_list=sorted(os.listdir(url))
label = 0
for i in s_list:
s_list=glob.glob(url+i+'/*.png')
# if(len(s_list)>25):
if(len(s_list)>500):
file=open(url+i+'/utf8',"r")
i_uni=file.read()
i_uni=i_uni[:-1]
label_list.append(i_uni)
label+=1
else:
continue
print str(label),i,label_list[label],len(s_list)
int test=10;
for j in s_list:
if(!test-=1)
break;
img=cv2.imread(j,0)
img=pp.preprocess(img)
f =train.find_feature(img.copy())
# print len(f)
s = [label,f]
train_set.append(s)
f=open('label','w')
for l in label_list:
f.write(l+'\n')
f.close()
shuffle(train_set)
f_list = []
label = []
for t in train_set:
label.append(t[0])
f_list.append(t[1])
# np.savetxt('feature.txt',f_list)
# np.savetxt('label.txt',label)
# samples = np.loadtxt('feature.txt',np.float32)
# responses = np.loadtxt('label.txt',np.float32)
# responses = responses.reshape((responses.size,1))
samples = np.array(f_list,np.float32)
responses = np.array(label,np.float32)
print 'auto training initiated'
print 'please wait.....'
svm.train(samples,responses,params=svm_params)
# svm.train_auto(samples,responses,None,None,params=svm_params)
svm.save("svm_class.xml")
def train_test_svm(tr_feat_targ, tst_feat_targ, retrain=True, model_fpath="models/svm.yaml",
C=2.0, gamma=3.0, iterations=50):
"""
Function trains and tests svm using given data and returns training & testing
errors
Input:
-----
tr_feat_targ,
tst_feat_targ: [mx(n+1)] matrices containing m samples, n features, targets
retrain : Trains new model if True, else loads model from model_fpath
model_fpath: Path to store / load svm models from
If there is an older model already in path & retrain is set 'True'
older model get overwritten
C, Gamma : SVM parameters
iterations : No of iterations to run SVM
"""
tr_feat = tr_feat_targ[:, :-1]
tr_targets = tr_feat_targ[:, -1]
tst_feat = tst_feat_targ[:, :-1]
tst_targets = tst_feat_targ[:, -1]
# Train/Load trained model and predict on training & testing set
if retrain:
svm, tr_preds = train_svm(tr_feat_targ, C, gamma, iterations, model_fpath)
else:
svm = cv2.SVM()
svm_model = svm.load(model_fpath)
tr_preds = test_svm(tr_feat, svm)
tst_preds = svm.predict(tst_feat)
# Compute erfloat32rors
tr_acc = (tr_targets == tr_preds[1].reshape(tr_preds[1].shape[0],)).astype(np.uint8)
tst_acc = (tst_targets == tst_preds[1].reshape(tst_preds[1].shape[0],)).astype(np.uint8)
mean_tr_acc = tr_acc.sum() / tr_acc.shape[0] * 100 # Mean training accuracy
mean_tst_acc = tst_acc.sum() / tst_acc.shape[0] * 100 # Mean testing accuracy
np.savetxt("tr_preds.txt", tr_preds[1], fmt="%.1f")
print "Training predictions written to tr_preds.txt"
np.savetxt("tst_preds.txt", tst_preds[1], fmt="%.1f")
print "Testing predictions written to tst_preds.txt"
print "******calculating training and testing accuracy******"
print "Training Accuracy: ", mean_tr_acc
print "Testing Accuracy: ", mean_tst_acc
# Plot errors
if ERR_VIS:
plt.ioff()
plt.plot(tr_acc)
plt.savefig("results/tr_acc.png")
plt.close()
plt.plot(tst_acc)
plt.savefig("results/tst_acc.png")
print "testing accuracy written to results/tst_acc.png"
plt.close()
return mean_tr_acc, mean_tst_acc
def __init__(self, **kwargs):
super(OTPFliesIdentificationLearning, self).__init__(**kwargs)
self._svm = cv2.SVM()
self._first = True
self.params = dict(kernel_type=cv2.SVM_RBF,
svm_type=cv2.SVM_C_SVC,
C=1,
gamma=0.5)
def __init__(self, trained_hog_file=None, trained_binary_file=None):
self.trained_hog_file = trained_hog_file
self.trained_binary_file = trained_binary_file
self.svm_hog = cv2.SVM()
#self.svm_binary = cv2.SVM()
if trained_hog_file is not None and trained_binary_file is not None:
self.load(trained_hog_file, trained_binary_file)
