def predict_emotion_paef():
model = svmutil.svm_load_model(
"C:/Users/Admin/PycharmProjects/Emotion_Detection/trained_models/paef_models/artphoto_train.txt.model"
)
mapping = {
0: "happy",
2: "fear",
3: "excitement",
4: "disgust",
6: "anger",
7: "sad"
}
with open('image_data.txt', 'r') as feature:
for line in feature:
line = line.strip()
feature_vector = line.split()[1:]
feature_vector = [
float(item.split(":")[-1]) for item in feature_vector
]
p_labs, p_acc, p_vals = svmutil.svm_predict([0], [feature_vector],
model)
print("p_labs")
print(p_labs)
lab = p_labs[0]
return mapping[int(lab)]
def read_trained(self, input_file, filename):
model_filename = self.get_model_filename(filename)
num_lines = int(input_file.readline().split()[0])
f = open(model_filename, 'w')
for i in range(num_lines):
f.write(input_file.readline())
f.close()
self._model = svm_load_model(model_filename)
os.remove(model_filename)
def read_trained ( self, input_file, filename ):
model_filename = self.get_model_filename(filename)
num_lines = int(input_file.readline().split()[0])
f = open(model_filename,'w')
for i in range(num_lines):
f.write(input_file.readline())
f.close()
self._model = svm_load_model(model_filename)
os.remove(model_filename)
def calcFtrs(seq):
ftrs = []
stc, mfe, efe, cstc, cmfe, cdst, frq, div, bpp = FOLDER.fold(seq)
kmer = kContent(seq, 1)
atcg = (kmer['a'] + kmer['t']) / (kmer['a'] + kmer['t'] + kmer['c'] + kmer['g'])
if kmer['a'] + kmer['t'] == 0:
at = 0
else:
at = kmer['a'] / (kmer['a'] + kmer['t'])
if kmer['c'] + kmer['g'] == 0:
cg = 0
else:
cg = kmer['c'] / (kmer['c'] + kmer['g'])
svmftrs = numpy.array((atcg, at, cg))
mfeavg_mdl = svmutil.svm_load_model(mfeavg200)
mfestd_mdl = svmutil.svm_load_model(mfestd200)
efeavg_mdl = svmutil.svm_load_model(efeavg200)
# efestd_mdl = svmutil.svm_load_model(efestd200)
mfeavg_avg, mfeavg_std = loadRange(mfeavg200 + '.rng')
mfestd_avg, mfestd_std = loadRange(mfestd200 + '.rng')
efeavg_avg, efeavg_std = loadRange(efeavg200 + '.rng')
# efestd_avg, efestd_std = loadRange(efestd200 + '.rng')
mfe_avg = svmutil.svm_predict([0],
[((svmftrs - mfeavg_avg) / mfeavg_std).tolist()], mfeavg_mdl, options='-b 1')[0][0]
mfe_std = svmutil.svm_predict([0],
[((svmftrs - mfestd_avg) / mfestd_std).tolist()], mfestd_mdl, options='-b 1')[0][0]
efe_avg = svmutil.svm_predict([0],
[((svmftrs - efeavg_avg) / efeavg_std).tolist()], efeavg_mdl, options='-b 1')[0][0]
# efe_std = svmutil.svm_predict([0],
# [((svmftrs - efestd_avg) / efestd_std).tolist()], efestd_mdl, options='-b 1')[0][0]
ftrs.append(mfe - mfe_avg)
ftrs.append((mfe - mfe_avg) / mfe_std)
ftrs.append(efe - efe_avg)
# ftrs.append((efe - efe_avg) / efe_std)
return numpy.array(ftrs)
def libSVM_converter(args):
# not using target_opset for libsvm convert since the converter is only generating operators in ai.onnx.ml domain
# but just passing in target_opset for consistency
from libsvm.svmutil import svm_load_model
source_model = svm_load_model(args.source)
from onnxmltools.convert import convert_libsvm
from onnxmltools.convert.common.data_types import FloatTensorType
onnx_model = convert_libsvm(source_model,
initial_types=[('input',
FloatTensorType([1, 'None']))],
target_opset=get_opset(args.ONNXVersion))
return onnx_model
def calculate_image_quality_score(brisque_features):
model = svmutil.svm_load_model('utils/brisque/brisque_svm.txt')
scaled_brisque_features = scale_features(brisque_features)
x, idx = svmutil.gen_svm_nodearray(
scaled_brisque_features,
isKernel=(model.param.kernel_type == svmutil.PRECOMPUTED))
nr_classifier = 1
prob_estimates = (svmutil.c_double * nr_classifier)()
return svmutil.libsvm.svm_predict_probability(model, x, prob_estimates)
def load_model(self, model_file, check_size=True):
"""
Taken from: https://github.com/Duke-GCB/Predict-TF-Binding
Loads a svm model from a file and computes its size
:param model_file: The file name of the model to load
:return: A dictionary with keys model, file, and size
"""
model = svmutil.svm_load_model(model_file)
model_dict = {'model': model}
if check_size:
# with >= libsvm-3.24, use this
model_dict['size'] = len(model.get_SV()[0])
# with < libsvm-3.24, use this
# model_dict['size'] = len(model.get_SV()[0]) - 1 # sv includes a -1 term that is not present in the model file, so subtract 1
return model_dict
def calculate_image_quality_score(brisque_features):
'''
Using a pre-trained SVR model we calculate the quality assessment scores.
'''
model = svmutil.svm_load_model(os.path.join("deeppixel", "iqa", "brisque_svm.txt"))
scaled_brisque_features = scaled(brisque_features)
x, idx = svmutil.gen_svm_nodearray(
scaled_brisque_features,
isKernel=(model.param.kernel_type == svmutil.PRECOMPUTED))
nr_classifier = 1
prob_estimates = (svmutil.c_double * nr_classifier)()
return svmutil.libsvm.svm_predict_probability(model, x, prob_estimates)
def __init__(self):
self._model = svmutil.svm_load_model(root_path('brisque', 'allmodel'))
self._scaler = np.array([
[-1, 1], [0.338, 10], [0.017204, 0.806612], [0.236, 1.642],
[-0.123884, 0.20293],[0.000155, 0.712298], [0.001122, 0.470257],
[0.244, 1.641], [-0.123586, 0.179083], [0.000152, 0.710456],
[0.000975, 0.470984], [0.249, 1.555], [-0.135687, 0.100858],
[0.000174, 0.684173], [0.000913, 0.534174], [0.258, 1.561],
[-0.143408, 0.100486], [0.000179, 0.685696], [0.000888, 0.536508],
[0.471, 3.264], [0.012809, 0.703171], [0.218, 1.046],
[-0.094876, 0.187459], [1.5e-005, 0.442057], [0.001272, 0.40803],
[0.222, 1.042], [-0.115772, 0.162604], [1.6e-005, 0.444362],
[0.001374, 0.40243], [0.227, 0.996],
[-0.117188, 0.09832299999999999], [3e-005, 0.531903],
[0.001122, 0.369589], [0.228, 0.99], [-0.12243, 0.098658],
[2.8e-005, 0.530092], [0.001118, 0.370399]])
def load_model(self):
if not os.path.isfile(self._modelname+"/"+self._pref+".model"):
return False
if self._classtype == "classifier":
self._model = svmutil.svm_load_model(self._modelname+\
"/"+self._pref+".model")
elif self._classtype == "structured":
self._model = svmlight.read_model(self._modelname+\
"/"+self._pref+".model")
elif self._classtype == "percrank":
m = KernelLBRankPerceptron(kernel=polynomial_kernel)
mfile = open(self._modelname+"/"+self._pref+".model", 'rb')
m.sv_a,m.sv_1,m.sv_2,m.bias = cPickle.load(mfile)
mfile.close()
self._model = m
return True
def predict(data, path):
if not os.path.exists(path):
print 'Model path does not exist, do nothing.'
return
print "Loading features."
integerizer = tools.integerization.CIntegerization.read(os.path.join(path, 'int'))
model = svmutil.svm_load_model(os.path.join(path, "scr"))
print "Decoding."
for sent in posreader.readpossent(data):
print sent
for start in range(len(sent)):
for end in range(start, len(sent)):
label, feature = extractfeat.extractOneFeat(sent, (start, end, None), integerizer)
assert label == -1
nodes, x = svmutil.gen_svm_nodearray(feature)
label = svm.libsvm.svm_predict(model, nodes)
probabilities = (ctypes.c_double*2)()
label = svm.libsvm.svm_predict_probability(model, nodes, probabilities)
print start, end, probabilities[0], probabilities[1]
def __init__(self,
training_datafile,
classifier_dumpfile,
training_required=0):
self.feature_list = open('app/data/feature_list.txt').readlines()
self.training_datafile = training_datafile
self.classifier_dumpfile = classifier_dumpfile
# call training model
if (training_required):
self.classifier = self.get_SVM_trained_classifer(
training_datafile, classifier_dumpfile)
else:
fp = open(classifier_dumpfile, 'r')
if (fp):
self.classifier = svm_load_model(classifier_dumpfile)
else:
self.classifier = self.get_SVM_trained_classifer(
training_datafile, classifier_dumpfile)
def predict(data, path):
if not os.path.exists(path):
print 'Model path does not exist, do nothing.'
return
print "Loading features."
integerizer = tools.integerization.CIntegerization.read(os.path.join(path, 'int'))
model = svmutil.svm_load_model(os.path.join(path, "scr"))
print "Working."
for sent in io.getsent(data):
labels = []
for index in range(len(sent)):
f = feature.extractFeatures(sent, index, integerizer)
nodes, x = svmutil.gen_svm_nodearray(f)
probabilities = (ctypes.c_double*2)()
label = svm.libsvm.svm_predict_probability(model, nodes, probabilities)
x = 1
if probabilities[0] > cutoff:
x = 0
labels.append(str(x))
print ' '.join(labels)
def predict(data, path):
if not os.path.exists(path):
print 'Model path does not exist, do nothing.'
return
print "Loading features."
integerizer = tools.integerization.CIntegerization.read(
os.path.join(path, 'int'))
model = svmutil.svm_load_model(os.path.join(path, "scr"))
print "Working."
for sent in io.getsent(data):
labels = []
for index in range(len(sent)):
f = feature.extractFeatures(sent, index, integerizer)
nodes, x = svmutil.gen_svm_nodearray(f)
probabilities = (ctypes.c_double * 2)()
label = svm.libsvm.svm_predict_probability(model, nodes,
probabilities)
x = 1
if probabilities[0] > cutoff:
x = 0
labels.append(str(x))
print ' '.join(labels)
def predict_emotion_paef():
model = svmutil.svm_load_model("C:/Users/Admin/PycharmProjects/Emotion_Detection/trained_models/paef_models/artphoto_train.txt.model")
mapping = {
0 : "happy",
2 : "fear",
3 : "excitement",
4 : "disgust",
6 : "anger",
7 : "sad"
}
with open('image_data.txt', 'r') as feature:
for line in feature:
line = line.strip()
feature_vector = line.split()[1:]
feature_vector = [float(item.split(":")[-1]) for item in feature_vector]
p_labs, p_acc, p_vals = svmutil.svm_predict([0], [feature_vector], model)
print("p_labs")
print(p_labs)
lab = p_labs[0]
return mapping[int(lab)]
def main(args):
ref_path = args.ref_path
height = args.height
width = args.width
ref_fps = args.ref_fps
bit_depth = args.bit_depth
if bit_depth == 8:
pix_format = 'yuv420p'
else:
pix_format = 'yuv420p10le'
fps = args.dist_fps #frame rate of distorted sequence
#Obtain pseudo reference video by frame dropping using ffmpeg
cmd = 'ffmpeg -r '+ str(ref_fps) +' -pix_fmt ' + pix_format + ' -s ' + str(width) +\
'x' + str(height) + ' -i '+ ref_path + ' -filter:v fps=fps=' +\
str(fps) + ' pseudo_reference.yuv'
os.system(cmd)
GREED_feat = greed_feat(args)
#load svm model
model = svm_load_model('model_params/' + args.temp_filt + '.model')
#load parameter of trained features
feat_param = scipy.io.loadmat('model_params/' + args.temp_filt +
'_params.mat')
low = feat_param['low'][0, :]
high = feat_param['high'][0, :]
GREED_feat = (GREED_feat - low) / (high - low)
#Predict score
score, _, _ = svm_predict([0.0], GREED_feat[None, :], model, '-q')
print(score)
def main():
m=svmutil.svm_load_model('trained_models/svm.model')
relation_tag={0:'None',1:'has_value',2:'has_temp',3:'modified_by'}
match=re.search('^(.*)\.txt',sys.argv[2])
filename=sys.argv[2]
if match:
filename=match.group(1)
input_dir=sys.argv[1]+'/'+filename+'_NER.xml'
output_dir=sys.argv[1]+'/'+filename+'_Parsed.xml'
print "Reading NER results from ", input_dir
tree = ET.ElementTree(file=input_dir)
root = tree.getroot()
relations={}
index=[]
for child in root:
syn_features=codecs.open('Tempfile/relation_scale','w')
temp_pairs=relation_features.generate_pairs(child,syn_features)
if temp_pairs:
try:
y,x=svmutil.svm_read_problem('Tempfile/relation_scale')
p_label,p_acc,p_val=svmutil.svm_predict(y,x,m)
except ValueError:
for child2 in child.findall('text'):
print child2.text
continue
#print len(p_label),len(temp_pairs)
else:
p_label=[]
temp_pairs=[]
for j in range(0,len(p_label)):
#print j
relations[temp_pairs[j]]=p_label[j]
indexes=temp_pairs[j].split("_")
index.append(indexes[0])
index.append(indexes[1])
for child2 in child.findall('entity'):
node_index=child2.attrib['index']
child2.attrib['relation']='None'
if node_index in index:
right_pattern='^(\w+)_'+node_index
left_pattern=node_index+'_(\w+)$'
for relation in relations:
match1=re.search(left_pattern,relation)
match2=re.search(right_pattern,relation)
other_index= None
if match1:
other_index=match1.group(1)
else:
if match2:
other_index=match2.group(1)
else:
continue
relation_type=relation_tag[relations[relation]]
if relation_type == 'None':
continue
if child2.attrib['relation'] is 'None':
child2.attrib['relation']=other_index+":"+relation_type
else:
child2.attrib['relation']=child2.attrib['relation']+"|"+other_index+":"+relation_type
#print child2.text,child2.attrib['index'],child2.attrib['relation']
relation_excuted=os.path.exists("in.parse")
if relation_excuted:
os.system('rm in.parse')
os.system('rm Tempfile/relation_scale')
print "Writing Relation xml to ", output_dir
new_tree=codecs.open(output_dir,'w')
tree.write(new_tree)
print "Finished!"
#!/usr/bin/env python3
import libsvm.svmutil as svm
import sys
if __name__ == "__main__":
model_path = "test.model"
if len(sys.argv) == 2:
model_path = sys.argv[1]
model = svm.svm_load_model(model_path)
for line in sys.stdin:
line = line.strip()
x = line.split(' ')
try:
vx = [{i + 1: float(x[i]) for i in range(len(x))}]
except:
continue
print('vx = ', vx)
p_label, p_acc, p_val = svm.svm_predict([], vx, model, '-q')
print('p_val = ', p_val)
innersurround = max(patch[18, 20], patch[20, 18], patch[22, 20],
patch[20, 22], patch[18, 18], patch[18, 22],
patch[22, 18], patch[22, 22])
centre = np.sum([
patch[20, 20], patch[20, 21], patch[20, 19], patch[19, 20],
patch[21, 20]
])
res = np.array([[
searchmax, centremax, mean, outersurround, innersurround,
centre
]])
_, _, pred = svm_predict([], res, model, '-q')
else:
pred = None
contact.append({
'x': x + imgcorrection,
'y': y + imgcorrection,
'patch': patch,
'searchpatch': searchpatch,
'mean': mean,
'searchmax': searchmax,
'centremax': centremax,
'confident': confident,
'prediction': pred[0][0]
})
return contact, found, searchimg
pathtoretrodetect = os.path.dirname(__file__)
model = svm_load_model(pathtoretrodetect + '/beetrack.model')
def load_model(self):
self.model = svm_load_model(self.svm_model_file)
def load_trained_models():
global models
for i in range(len(config.MODEL_LABEL)):
models.append(svmutil.svm_load_model("model" + str(i)))
return models
@author: Nikolay
"""
import csv
import os
from libsvm import svmutil
from prepare_libsvm import load_sda
from chord_utils import list_spectrum_data, through_sda_layers
model_file = 'model/svm.dat'
sda = load_sda()
model = svmutil.svm_load_model(model_file)
chord_list = ['A#-C#-F', 'A#-C#-F#', 'A#-D#-F#', 'A#-D#-G',
'A#-D-F', 'A#-D-G', 'A-C#-E', 'A-C#-F#', 'A-C-E',
'A-C-F', 'A-D-F', 'A-D-F#', 'B-D#-F#', 'B-D#-G#',
'B-D-F#', 'B-D-G', 'B-E-G', 'B-E-G#', 'C#-E-G#',
'C#-F-G#', 'C-D#-G', 'C-D#-G#', 'C-E-G', 'C-F-G#', 'N']
def process_file(source, target):
with open(source, 'rb') as i:
reader = csv.reader(i)
(before, chords) = list_spectrum_data(reader, components=60, allow_no_chord=True)
sda_features = through_sda_layers(sda, before)
# append chord labels as integer numbers
sda_features = [x.tolist() for x in sda_features]
(labels, acc, vals) = svmutil.svm_predict([0] * len(sda_features), sda_features, model)
result = [chord_list[int(x)] for x in labels]
def __setstate__(self, data):
f = tempfile.NamedTemporaryFile(delete=False)
with open(f.name, "wb") as h:
h.write(data['by'])
self.model = svmutil.svm_load_model(f.name)
os.remove(f)
import PIL.Image
import numpy
import scipy.signal
import skimage.color
import skimage.transform
from libsvm import svmutil
from imquality.models import MODELS_PATH
from imquality.statistics import AsymmetricGeneralizedGaussian, gaussian_kernel2d
from imquality.utils import pil2ndarray
with open(os.path.join(MODELS_PATH, "normalize.pickle"), "rb") as file:
scale_parameters = pickle.load(file)
model = svmutil.svm_load_model(os.path.join(MODELS_PATH, "brisque_svm.txt"))
class MscnType(Enum):
mscn = 1
horizontal = 2
vertical = 3
main_diagonal = 4
secondary_diagonal = 5
class Brisque:
_local_mean = None
_local_deviation = None
_mscn = None
_features = None
def get_dataset(fname,k):
labels = []
features = []
for prot_id,seq in seq2feature.parse_fasta(fname):
labels.append(prot_id)
features.append(k_spec(seq,k))
return labels,features
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Predict X binding proteins.')
parser.add_argument('-model',action="store",dest="model")
parser.add_argument('-thr',action="store",dest="thr",type = float)
parser.add_argument('-fname',action="store",dest="fname")
model = parser.parse_args().model
fname = parser.parse_args().fname
thr = parser.parse_args().thr
labels,features = get_dataset(fname,2)
model = svmutil.svm_load_model(model)
plbl, pacc, pvals = svmutil.svm_predict([0]*len(features),features,model,"")
for cnt,(prot_id,seq) in enumerate(seq2feature.parse_fasta(fname)):
pval = pvals[cnt][0]
if pval >= thr:
print "> %s:%f" % (prot_id,pval)
print seq
def main():
m = svmutil.svm_load_model('trained_models/svm.model')
relation_tag = {0: 'None', 1: 'has_value', 2: 'has_temp', 3: 'modified_by'}
match = re.search('^(.*)\.txt', sys.argv[2])
filename = sys.argv[2]
if match:
filename = match.group(1)
input_dir = sys.argv[1] + '/' + filename + '_NER.xml'
output_dir = sys.argv[1] + '/' + filename + '_Parsed.xml'
print "Reading NER results from ", input_dir
tree = ET.ElementTree(file=input_dir)
root = tree.getroot()
relations = {}
index = []
for child in root:
syn_features = codecs.open('Tempfile/relation_scale', 'w')
temp_pairs = relation_features.generate_pairs(child, syn_features)
if temp_pairs:
try:
y, x = svmutil.svm_read_problem('Tempfile/relation_scale')
p_label, p_acc, p_val = svmutil.svm_predict(y, x, m)
except ValueError:
for child2 in child.findall('text'):
print child2.text
continue
#print len(p_label),len(temp_pairs)
else:
p_label = []
temp_pairs = []
for j in range(0, len(p_label)):
#print j
relations[temp_pairs[j]] = p_label[j]
indexes = temp_pairs[j].split("_")
index.append(indexes[0])
index.append(indexes[1])
for child2 in child.findall('entity'):
node_index = child2.attrib['index']
child2.attrib['relation'] = 'None'
if node_index in index:
right_pattern = '^(\w+)_' + node_index
left_pattern = node_index + '_(\w+)$'
for relation in relations:
match1 = re.search(left_pattern, relation)
match2 = re.search(right_pattern, relation)
other_index = None
if match1:
other_index = match1.group(1)
else:
if match2:
other_index = match2.group(1)
else:
continue
relation_type = relation_tag[relations[relation]]
if relation_type == 'None':
continue
if child2.attrib['relation'] is 'None':
child2.attrib[
'relation'] = other_index + ":" + relation_type
else:
child2.attrib['relation'] = child2.attrib[
'relation'] + "|" + other_index + ":" + relation_type
#print child2.text,child2.attrib['index'],child2.attrib['relation']
relation_excuted = os.path.exists("in.parse")
if relation_excuted:
os.system('rm in.parse')
os.system('rm Tempfile/relation_scale')
print "Writing Relation xml to ", output_dir
new_tree = codecs.open(output_dir, 'w')
tree.write(new_tree)
print "Finished!"
def get_indexes(kind):
train_str = cfg.get('indexes', kind)
indexes = eval(train_str)
result = [j for i in indexes for j in range(i[0], i[2], i[1])]
return sorted(result)
cfg = ConfigParser()
cfg.read('config.ini')
f = open(cfg.get('kmeans', 'path'), 'rb')
kmeans = pickle.loads(f.read())
f.close()
train_indexes = get_indexes('train')
bootstrap_indexes = get_indexes('bootstrap')
test_indexes = get_indexes('test')
slide = cfg.getint('params', 'slide')
folder = cfg.get('params', 'folder')
neg_weight = cfg.getint('params', 'neg_weight')
marginX = cfg.getint('params', 'marginX')
marginY = cfg.getint('params', 'marginY')
non_max_thresh = cfg.getfloat('params', 'non_max_threshold')
get_c_iteration = cfg.getboolean('svm', 'c_iteration')
def_c_value = cfg.getfloat('svm', 'def_c_value')
s_windows = eval(cfg.get('svm', 's_windows'))
svm = svm_load_model(cfg.get('svm', 'path'))
mode = cfg.get('configs', 'mode')