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 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)
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})