def getconnection(dbname):
#TODO: multiple connections for GridFS and mongoengine, reduce to one
connect_to_database(dbname) #mongoengine database connection
db = create_connection(
database=dbname) #generic pymongo database connection
dbfile = GridFS(db) #GridFS database connection
return db, dbfile
def process_db_energy():
"""
Train new GMM for each audio cut in database, label each window,
and return index for speech-containing frames
"""
from clint.textui.progress import bar
from spkrec.db.schema import Mfcc
from spkrec.db.mongoengine_ext import connect_to_database
connected = connect_to_database()
if not connected:
print 'ENERGYDETECTOR: Could not connect to database'
raise
#Hack to prevent DB cursor from timing out
cnt = Mfcc.objects.count()
ind = np.floor(np.linspace(0,cnt,15))
for i in range(0,len(ind)-1):
for mfcc in bar(Mfcc.objects[ind[i]:ind[i+1]]):
energy_vec = np.reshape(mfcc.energy, (np.size(mfcc.energy,0),1))
detected_speech = classify_speech(energy_vec)
mfcc.energydetectorindex = detected_speech
mfcc.save(safe=True)
def port_sv():
print '---- Porting the SV database ----'
db1 = connect_to_database()
db1.add_son_manipulator(TransformToBinary())
db = NeoEngine('/data/neo4j')
db.create_collection('sv')
cnt = db1.sv.find().count()
cntidx = bar([i for i in range(cnt)])
for sv in db1.sv.find():
#print type(sv['sv'].value())
cntidx.next()
data = {'speaker_name': _udecode(sv['speaker_name']),
'sv': sv['sv'].value(),
'random': random.random()}
node = db.insert('sv', data)
# check data integrity
try:
assert _udecode(sv['speaker_name']) == db.get('sv', {'id': node['id']})['speaker_name']
assert np.array_equal(sv['sv'].value(), NeoCustomType(node['sv']))
except Exception:
print sv['speaker_name']
db.shutdown()
db.create_index('sv', 'speaker_name')
db.shutdown()
def process_db_energy():
"""
Train new GMM for each audio cut in database, label each window,
and return index for speech-containing frames
"""
from clint.textui.progress import bar
from spkrec.db.schema import Mfcc
from spkrec.db.mongoengine_ext import connect_to_database
connected = connect_to_database()
if not connected:
print 'ENERGYDETECTOR: Could not connect to database'
raise
#Hack to prevent DB cursor from timing out
cnt = Mfcc.objects.count()
ind = np.floor(np.linspace(0, cnt, 15))
for i in range(0, len(ind) - 1):
for mfcc in bar(Mfcc.objects[ind[i]:ind[i + 1]]):
energy_vec = np.reshape(mfcc.energy, (np.size(mfcc.energy, 0), 1))
detected_speech = classify_speech(energy_vec)
mfcc.energydetectorindex = detected_speech
mfcc.save(safe=True)
def map_adapt_concurrent(t, world, worker, concurrency):
db = connect_to_database()
db.add_son_manipulator(TransformToBinary())
cursor = Concurrent_cursor(
Mfcc.objects(__raw__={'speaker_name': {
'$ne': 'anonymous'
}}))
cursor.set_concurrency(concurrency)
#print "eat it bitch"
#print cursor.concurrency
silent_records = 0
cursor.set_worker(worker)
#print cursor.worker
for mfcc in bar(cursor.search_path()):
mfcc_speech = strip_silence(mfcc.data, mfcc.energydetectorindex)
# Check for silent recordings and skip if found
if not mfcc_speech.any():
silent_records = silent_records + 1
continue
#Compute number of full windows of len t
ind = np.arange(0, np.size(mfcc_speech, 0), t / .01)
if len(ind) > 1:
for i in range(len(ind) - 1):
obs = mfcc_speech[ind[i]:ind[i + 1], :]
model_w, model_u = map_adapt_speaker(obs, world)
model_rec = {
'base_ubm':
mfcc.id,
'speaker_name':
mfcc.speaker_name,
'speaker':
mfcc.speaker,
'train_time':
t,
'model_weights':
NumpyArrayField(
np.reshape(model_w, (np.size(model_w, 0), 1))),
'model_means':
NumpyArrayField(model_u)
}
db.model.insert(model_rec, safe=True)
#m = Model()
#m.base_ubm = mfcc.id
#m.speaker_name = mfcc.speaker_name
#m.speaker = mfcc.speaker
#m.train_time = t
#m.model_weights = np.reshape(model_w, (np.size(model_w,0),1))
#m.model_means = model_u
#m.save(validate=False)
print "Number of silent records: %s" % str(silent_records)
def add_random_queryfield(collection):
c = connect_to_database()
for rec in bar(collection.objects()):
rec.random = np.random.ranf()
rec.save(safe=True)
collection.objects.ensure_index('random')
def add_random_queryfield(collection):
c = connect_to_database()
for rec in bar(collection.objects()):
rec.random = np.random.ranf()
rec.save(safe=True)
collection.objects.ensure_index('random')
def map_adapt_concurrent(t, world, worker, concurrency):
db = connect_to_database()
db.add_son_manipulator(TransformToBinary())
cursor = Concurrent_cursor(Mfcc.objects(__raw__={'speaker_name': {'$ne': 'anonymous'}}))
cursor.set_concurrency(concurrency)
#print "eat it bitch"
#print cursor.concurrency
silent_records = 0
cursor.set_worker(worker)
#print cursor.worker
for mfcc in bar(cursor.search_path()):
mfcc_speech = strip_silence(mfcc.data, mfcc.energydetectorindex)
# Check for silent recordings and skip if found
if not mfcc_speech.any():
silent_records = silent_records + 1
continue
#Compute number of full windows of len t
ind = np.arange(0, np.size(mfcc_speech,0), t/.01)
if len(ind) > 1:
for i in range(len(ind)-1):
obs = mfcc_speech[ind[i]:ind[i+1],:]
model_w, model_u = map_adapt_speaker(obs, world)
model_rec = {'base_ubm': mfcc.id,
'speaker_name': mfcc.speaker_name,
'speaker': mfcc.speaker,
'train_time': t,
'model_weights': NumpyArrayField(np.reshape(model_w, (np.size(model_w,0),1))),
'model_means': NumpyArrayField(model_u)}
db.model.insert(model_rec, safe=True)
#m = Model()
#m.base_ubm = mfcc.id
#m.speaker_name = mfcc.speaker_name
#m.speaker = mfcc.speaker
#m.train_time = t
#m.model_weights = np.reshape(model_w, (np.size(model_w,0),1))
#m.model_means = model_u
#m.save(validate=False)
print "Number of silent records: %s" % str(silent_records)
def create_ubm(mins=.2):
from clint.textui.progress import bar
from spkrec.db.schema import Mfcc
from spkrec.db.mongoengine_ext import connect_to_database
from energydetector import strip_silence
from pprint import pprint
MIN_MINUTES = mins
connected = connect_to_database()
if not connected:
print 'CREATE_UBM: Could not connect to database'
raise
#Hack to prevent DB cursor from timing out
cnt = Mfcc.objects(__raw__={'speaker_name': 'anonymous'}).count()
ind = np.floor(np.linspace(0,cnt,15))
obs = np.array([])
for i in range(0,len(ind)-1):
for mfcc in bar(Mfcc.objects[ind[i]:ind[i+1]]):
# Strip silence from MFCCs
mfcc_speech = strip_silence(mfcc.data, mfcc.energydetectorindex)
# Check for silent recordings and skip if found
if not mfcc_speech.any():
continue
# Concatenate new speech data to end of observation array
if not obs.any():
obs = mfcc_speech
else:
obs = np.concatenate((obs,mfcc_speech),0)
if np.size(obs,0) > (MIN_MINUTES * 60 / .01):
break
if np.size(obs,0) > (MIN_MINUTES * 60 / .01):
break
world = train_gmm(obs,params={'num_mixtures': 1024})
pprint(np.shape(world.means))
pprint(np.shape(world.weights))
pprint(np.shape(world.covars))
return world
def test_port_speaker():
print '---- Testing speaker database integrity ----'
db1 = connect_to_database()
db = NeoEngine('/data/neo4j')
for speaker in bar(Speaker.objects):
nodes = db.get('speaker', {'name': _udecode(speaker.name)})
if len(nodes) > 1:
print len(nodes)
raise Exception, "Non-unique name in database"
node = nodes.single
for key in ['name', 'gender', 'language', 'dialect']:
try:
assert _udecode(speaker[key]) == node[key]
except AssertionError:
print "Failed (%s): %s" % (key, speaker.name)
db.shutdown()
def port_speaker():
print '---- Porting the Speaker database ----'
db1 = connect_to_database()
#db1.add_son_manipulator(TransformToBinary())
# set up neo4j collection
db = NeoEngine('/data/neo4j')
db.create_collection('speaker')
for speaker in bar(Speaker.objects):
data = {'name': _udecode(speaker.name), 'gender': _udecode(speaker.gender),
'language': _udecode(speaker.language),
'dialect': _udecode(speaker.dialect)}
node = db.insert('speaker', data)
db.create_index('speaker', 'name')
db.shutdown()
def create_SV_from_GMM(worker, concurrency):
db = connect_to_database()
#print db
db.add_son_manipulator(TransformToBinary())
#print db.collection_names()
model = db['spkrec']
#print model
#total_cnt = db.model.count()
#total_cnt = model.count()
#print total_cnt
cursor = Concurrent_cursor(db.model.find())
cursor.set_concurrency(concurrency)
cursor.set_worker(worker)
total_cnt = cursor.search_path().count()
#print cursor.cursor
u = Ubm.objects.first()
#print np.shape(u.ubm_weights)
#print np.shape(u.ubm_means)
#print np.shape(u.ubm_vars)
bar_iter = bar([i for i in range(total_cnt)])
for model in cursor.search_path():
bar_iter.next()
#print iter_num
#print np.shape(model.model_means)
sv_data = create_supervector(u.ubm_weights,
model['model_means'].value(), u.ubm_vars)
#print np.shape(sv_data)
sv_rec = {
'base_model': model['_id'],
'sv': NumpyArrayField(sv_data),
'speaker_name': model['speaker_name'],
'speaker': model['speaker'],
'random': np.random.ranf()
}
db.sv.insert(sv_rec, safe=True)
def create_SV_from_GMM(worker, concurrency):
db = connect_to_database()
#print db
db.add_son_manipulator(TransformToBinary())
#print db.collection_names()
model = db['spkrec']
#print model
#total_cnt = db.model.count()
#total_cnt = model.count()
#print total_cnt
cursor = Concurrent_cursor(db.model.find())
cursor.set_concurrency(concurrency)
cursor.set_worker(worker)
total_cnt = cursor.search_path().count()
#print cursor.cursor
u = Ubm.objects.first()
#print np.shape(u.ubm_weights)
#print np.shape(u.ubm_means)
#print np.shape(u.ubm_vars)
bar_iter = bar([i for i in range(total_cnt)])
for model in cursor.search_path():
bar_iter.next()
#print iter_num
#print np.shape(model.model_means)
sv_data = create_supervector(u.ubm_weights, model['model_means'].value(), u.ubm_vars)
#print np.shape(sv_data)
sv_rec = {'base_model': model['_id'],
'sv': NumpyArrayField(sv_data),
'speaker_name': model['speaker_name'],
'speaker': model['speaker'],
'random': np.random.ranf()}
db.sv.insert(sv_rec, safe=True)
def test_accuracy_concurrent(worker, concurrency):
TEST_FOLD = 2
RUN_MAX = False
iter_num = 0
db = connect_to_database()
db.add_son_manipulator(TransformToBinary())
#take this out later when testing complete
fid = open('/home/ubuntu/project/backend-search/src/spkrec/utils/hist'+str(worker)+'.csv', 'wb')
csv_writer = csv.writer(fid)
if worker == 0:
csv_writer.writerow(['name', 'num speaker SVs', 'test subjects', 'test impostors', 'correct subject', 'correct impostor', 'false neg', 'false pos'])
cursor = Concurrent_cursor(Speaker.objects())
cursor.set_concurrency(concurrency)
cursor.set_worker(worker)
for speaker in Speaker.objects():
#Impostor ratio is ratio of impostor records in training
#and testing population. For ratio=N, subject is 1/(N+1),
#impostor N/(N+1) of population
IMPOSTOR_RATIO = 3
#Find all SVs for current subject
print 'Speaker Name: %s' % speaker.name
#print 'Count:', db.sv.find({'speaker_name': speaker.name}).count()
#cursor_subject = Concurrent_cursor(SV.objects(speaker_name=speaker.name))
sv_subject = stack_SVs(db.sv.find({'speaker_name': speaker.name}))
num_subject = np.size(sv_subject,0)
#csv_writer.writerow([speaker.name, num_subject])
#print num_subject
if num_subject < 20:
continue
#Get random SVs from rest of database for test population
#cursor_impostor = db.sv.find({'speaker_name': {'$ne': speaker['name']}})
sv_impostor = stack_SVs_random(db, speaker.name, num_subject*IMPOSTOR_RATIO)
num_impostor = np.size(sv_impostor,0)
print 'Subject: %i, Impostor: %i' % (num_subject, num_impostor)
#generate total dataset of observations X with class labels y
X = np.vstack((sv_subject, sv_impostor))
y = np.array([1] * num_subject + [0] * num_impostor)
#Pick random assortment from each set to form training observations
#Switch ensures that smaller number always used for training
if TEST_FOLD < 3:
train, test = iter(StratifiedKFold(y, TEST_FOLD)).next()
else:
test, train = iter(StratifiedKFold(y, TEST_FOLD)).next()
#print train
#Perform crossvalidated SVM training
#print type(X), type(y)
#print np.shape(X[train]), np.shape(y[train])
clf = train_svm_crossvalidated(X[train], y[train])
#print type(clf)
#clf_rec = {'classifier': SVMModelField(clf), 'speaker_name': speaker.name}
#db.svm.insert(clf_rec, safe=True)
#Collect classification statistics
accuracy = test_svm_accuracy(X[test], y[test], clf)
num_subject_test = np.sum(y[test])
num_impostor_test = len(y[test]) - num_subject_test
print 'Accuracy: %f' % (float(accuracy['correct_subject'])/float(num_subject_test))
print 'Sub: %i/%i Imp: %i/%i' % (accuracy['correct_subject'], num_subject_test, accuracy['correct_impostor'], num_impostor_test)
print 'False Neg: %i False Pos: %i' % (accuracy['false_neg'], accuracy['false_pos'])
csv_writer.writerow([speaker.name, num_subject, num_subject_test, num_impostor_test, accuracy['correct_subject'], accuracy['correct_impostor'], accuracy['false_neg'], accuracy['false_pos']])
iter_num = iter_num + 1
#if RUN_MAX and iter_num >= RUN_MAX:
# print "I'm breaking"
# break
#print num_subject, num_impostor
fid.close()
print "Complete"
def transform_outgoing(self, son, collection):
for (key, value) in son.items():
if isinstance(value,
pymongo.binary.Binary) and value.subtype == 128:
son[key] = self.to_python(value)
elif isinstance(value, dict):
son[key] = self.transform_outgoing(value, collection)
#return CustomReturnDict(son)
return son
if __name__ == '__main__':
from spkrec.db.mongoengine_ext import connect_to_database
import numpy as np
db = connect_to_database('test', True)
db.add_son_manipulator(TransformToBinary())
#Test SVM model storage and retrieval
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
y = np.array([1, 1, 2, 2])
clf = svm.SVC()
clf.fit(X, y)
id = db.test.insert({'test': SVMModelField(clf), 'test2': 5})
val = db.test.find_one({'_id': id})
print val['test'], val['test2']
#Test Numpy array storage and retrieval
a = np.ones((1, 5))
id = db.test.insert({'test': NumpyArrayField(a), 'test2': 5})
val = db.test.find_one({'_id': id})
def getconnection(dbname):
#TODO: multiple connections for GridFS and mongoengine, reduce to one
connect_to_database(dbname) #mongoengine database connection
db = create_connection(database = dbname) #generic pymongo database connection
dbfile = GridFS(db) #GridFS database connection
return db, dbfile
u = Ubm.objects.first()
print "Im here"
world = convert_type_db_gmm(u)
#child = []
for i in range(CONCURRENCY):
print "Launching " + str(i)
map_adapt_concurrent.delay(t, world, i, CONCURRENCY)
#while not child.ready.all():
# sleep(5)
def convert_to_SV(CONCURRENCY=2):
for i in range(CONCURRENCY):
print "Launching " + str(i)
create_SV_from_GMM.delay(i, CONCURRENCY)
if __name__ == '__main__':
connected = connect_to_database()
if not connected:
print 'MAPADAPT: Could not connect to database'
raise
#map_adapt_all_models(2,1)
convert_to_SV(CONCURRENCY=1)
u = Ubm.objects.first()
print "Im here"
world = convert_type_db_gmm(u)
#child = []
for i in range(CONCURRENCY):
print "Launching " + str(i)
map_adapt_concurrent.delay(t, world, i, CONCURRENCY)
#while not child.ready.all():
# sleep(5)
def convert_to_SV(CONCURRENCY=2):
for i in range(CONCURRENCY):
print "Launching " + str(i)
create_SV_from_GMM.delay(i, CONCURRENCY)
if __name__ == '__main__':
connected = connect_to_database()
if not connected:
print 'MAPADAPT: Could not connect to database'
raise
#map_adapt_all_models(2,1)
convert_to_SV(CONCURRENCY=1)
for infile in dirlist:
outfile = infile.split('.')[0] + '.txt'
cmdline = ['scopy', '-o', 'ascii', infile, outfile]
subprocess.Popen(cmdline)
return True
if __name__ == '__main__':
# if run stand-alone, run all records in database
logging.basicConfig(filename='mfcc.log', level=logging.DEBUG)
from mongoengine import *
from spkrec.db.schema import *
from spkrec.db.mongoengine_ext import self_extract, connect_to_database
from clint.textui.progress import bar
connect_to_database()
tag = 'initial'
try:
configs = Config.objects.get(tags=tag,external_program='sfbcep')
#print configs.config_details
except Config.DoesNotExist:
#if not already an inital config entry, put in sane defaults
cfg = {'numcoefs': 13, 'numfilters': 26, 'timewindow': 20, 'overlap': 10, 'energy': True, 'normalize': True}
configs = Config()
configs.config_details = cfg
configs.external_program = 'sfbcep'
configs.tags = [tag]
configs.description= 'Initial population of the MFCC database; 20ms, 10ms overlap, normalized, energy.'
configs.save(safe=True)
#test_mongoengine_ext.py
from spkrec.db.mongoengine_ext import SVMModelField, connect_to_database
from spkrec.db.schema import SVM
from scikits.learn.svm import SVC
def test_SVMModelField():
X = [[0 ,0],[1, 1]]
y = [0, 1]
svm = SVM()
clf = SVC()
clf.fit(X,y)
a1 = clf.predict([[2.,2.]])
#print clf
#print a1
svm.classifier = clf
svm.save(safe=True)
s = SVM.objects.first()
#print s.classifier
a2 = s.classifier.predict([[2., 2.]])
#print a2
assert a1 == a2
if __name__ == '__main__':
connect_to_database()
test_SVMModelField()
return son
def transform_outgoing(self, son, collection):
for (key, value) in son.items():
if isinstance(value, pymongo.binary.Binary) and value.subtype == 128:
son[key] = self.to_python(value)
elif isinstance(value, dict):
son[key] = self.transform_outgoing(value, collection)
#return CustomReturnDict(son)
return son
if __name__ == '__main__':
from spkrec.db.mongoengine_ext import connect_to_database
import numpy as np
db = connect_to_database('test', True)
db.add_son_manipulator(TransformToBinary())
#Test SVM model storage and retrieval
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
y = np.array([1, 1, 2, 2])
clf = svm.SVC()
clf.fit(X,y)
id = db.test.insert({'test': SVMModelField(clf), 'test2': 5})
val = db.test.find_one({'_id': id})
print val['test'], val['test2']
#Test Numpy array storage and retrieval
a = np.ones((1,5))
id = db.test.insert({'test': NumpyArrayField(a), 'test2': 5})
val = db.test.find_one({'_id': id})
