def voiceiden(fname,mname):
db = GMMVoiceDB('models')
fname=fname.strip('.wav')
print fname
db.add_model(str(fname),str(mname))
out.insertHtml(QString("<font color=\"black\">%1</font>"))
out.insertPlainText("\nModel "+mname+" Successfully added to database\n")
def main():
parser = argparse.ArgumentParser(version="1.0", prog="Voice Recognition")
parser.add_argument("-a", "--add", action="store_true", help="Add a new source")
parser.add_argument("audio", type=str, help="Name of the audio file (*.wav)")
args = parser.parse_args()
audio = HOME_FOLDER + args.audio
db = GMMVoiceDB(HOME_FOLDER)
if args.add:
name = str(time.strftime("%d%m%Y%H%M%S"))
db.add_model(audio.split(".")[0], name)
else:
v = Voiceid(db, audio)
v.diarization()
dic = db.get_speakers()
dist = []
d2u = {}
for gender in dic:
users = dic[gender]
for u in users:
dist.append(db.match_voice(audio, u, gender)[u])
d2u[dist[-1]] = u
dist.sort(None, None, True)
if (dist[0] - dist[1] + CEIL) > EPS:
return d2u[dist[0]]
else:
return "unkonwn"
def voiceiden(fname, mname):
db = GMMVoiceDB('models')
fname = fname.strip('.wav')
print fname
db.add_model(str(fname), str(mname))
out.insertHtml(QString("<font color=\"black\">%1</font>"))
out.insertPlainText("\nModel " + mname +
" Successfully added to database\n")
def __init__(self, test_mode=None):
self.voiceid = None
#self.db = GMMVoiceDB('/home/michela/SpeakerRecognition/voiceid/scripts/test_db/')
self.db = GMMVoiceDB(os.path.expanduser('~/.voiceid/gmm_db/'))
#self._cluster = None
#self._partial_record_time = 5
self.test_mode = test_mode
self.queue_processes = []
self._observers = []
self._processing_thread = None
self._queue_thread = []
self.thrd_n = 2
self._scores = {}
self.threshold = -32.160
def segment_input(wavfile, dbpath='./voicedb'):
db = GMMVoiceDB(dbpath)
v = Voiceid(db, wavfile)
v.extract_speakers()
speaker_clusters={}
for c in v.get_clusters():
cluster = v.get_cluster(c)
print cluster
cluster.print_segments()
print
class AudioAnalyzer():
def __init__(self):
""" Init voice model """
self._config = ConfigParser.ConfigParser()
self._config.read("config.ini")
dbPath = os.getcwd() + "/" + self._config.get("Paths", "voiceDir")
self._db = GMMVoiceDB(dbPath)
def addUser(self, user, audio):
""" Add user to voice db """
return self._db.add_model(audio, user)
def getUserList(self):
""" Return users of voice db """
return self._db.get_speakers()
def checkAudio(self, audio):
""" Check voices inside audio file """
v = Voiceid(self._db, audio)
v.extract_speakers(quiet=True)
return v
def getTotalSpeakers(self, voiceObj):
""" List of all speakers in voice file """
return voiceObj.get_user()
def getBestUser(self, voiceObj):
""" Best near speaker in voice file """
userList = self.getTotalSpeakers(voiceObj)
print "UserList: " + str(userList)
return max(userList, key=userList.get)
def getBestUsers(self, voiceObj):
""" Best three near speakers in voice file """
userList = self.getTotalSpeakers(voiceObj)
print "UserList: " + str(userList)
if 'S0' in userList:
del userList['S0']
return sorted(userList, key=userList.get)[-3:]
def __init__(self, test_mode=None):
self.voiceid = None
# self.db = GMMVoiceDB('/home/michela/SpeakerRecognition/voiceid/scripts/test_db/')
self.db = GMMVoiceDB(os.path.expanduser("~/.voiceid/gmm_db/"))
# self._cluster = None
# self._partial_record_time = 5
self.test_mode = test_mode
self.queue_processes = []
self._observers = []
self._processing_thread = None
self._queue_thread = []
self.thrd_n = 2
self._scores = {}
self.threshold = -32.160
def main():
parser = argparse.ArgumentParser(version='1.0',prog='Voice Recognition')
parser.add_argument("-a", "--add", action="store_true", help="Add a new source")
parser.add_argument("audio", type=str, help="Name of the audio file (*.wav)")
args = parser.parse_args()
audio = HOME_FOLDER+args.audio
db = GMMVoiceDB(HOME_FOLDER)
if args.add:
print('Adding User...')
name = str(time.strftime("%d%m%Y%H%M%S"))
db.add_model(audio.split('.')[0], name)
print('User '+name+' Added!')
else:
print('Recognition...')
v = Voiceid(db, audio)
v.diarization()
dic = db.get_speakers()
dist = []
d2u = {}
for gender in dic:
users = dic[gender]
#print('Gender: ',gender)
for u in users:
#print(db.match_voice(audio, u, gender))
dist.append(db.match_voice(audio, u, gender)[u])
d2u[dist[-1]]=u
dist.sort(None, None, True)
if (dist[0]-dist[1]+CEIL)>EPS :
print(d2u[dist[0]])
else:
print('unkonwn')
print "Done!"
def voicerec(fname):
db = GMMVoiceDB('models')
v = Voiceid(db, fname)
v.extract_speakers()
txt = ''
for c in v.get_clusters():
cl = v.get_cluster(c)
cluster = str(cl)
cluster = cluster.split(' ')
cluster = cluster[1]
cluster = cluster.strip('(')
cluster = cluster.strip(')')
txt = txt + 'Speaker : ' + cluster
seg = str(cl.print_segments())
txt = txt + '\n' + seg
out.insertPlainText(txt + "\n")
}
requests.post('http://129.236.234.21:8080/message',
data=json.dumps(payload),
headers=HEADERS)
client.publish("ais/recognize/result/" + device_id + "/" + voice_path,
speaker)
os.remove(voice.get_file_basename() + '.seg')
os.remove(voice.get_file_basename() + '.g.seg')
os.remove(voice.get_file_basename() + '.s.seg')
w = voice.get_file_basename() + '.wav'
if voice.get_filename() != w:
os.remove(w)
shutil.rmtree(voice.get_file_basename())
except IOError:
print "voice file doesn't exist"
# voice_db_lock.release()
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
# set_maxthreads(trd)
db = GMMVoiceDB("voiceDB")
voice_db_lock = threading.Lock()
# client.connect("127.0.0.1", 1883, 60)
client.connect("iot.eclipse.org", 1883, 60)
# https://eclipse.org/paho/clients/python/docs/#network-loop
client.loop_forever()
def __init__(self):
""" Init voice model """
self._config = ConfigParser.ConfigParser()
self._config.read("config.ini")
dbPath = os.getcwd() + "/" + self._config.get("Paths", "voiceDir")
self._db = GMMVoiceDB(dbPath)
from voiceid.sr import Voiceid
from voiceid.db import GMMVoiceDB
import sys
# create voice db
db = GMMVoiceDB('voiceDB')
print "DB Models:"
print db.get_speakers()
v = Voiceid(db, sys.argv[1])
v.extract_speakers(False, True)
# Set cluster speaker
c = v.get_cluster('S1')
c.set_speaker('derek')
c = v.get_cluster('S6')
c.set_speaker('derek')
# update db
v.update_db()
print "DB Models:"
print db.get_speakers()
#Using voiceid(google opensource project) for voice recognisation using python
from voiceid.sr import Voiceid
from voiceid.db import GMMVoiceDB
db = GMMVoiceDB('mydir') #creating database/directory of registered voices
db.add_model('C:\Users\raman\Documents\raman.wma', 'Raman','M')
db.add_model('C:\Users\raman\Documents\lalit.wma', 'Lalit','M')
db.add_model('C:\Users\raman\Documents\aneesha.wma', 'Aneesha','F')
db.add_model('C:\Users\raman\Documents\priyanka.wma', 'Priyanka','F')
db.get_speakers() # this will get all the speakers in the database/directory
if(db.matchvoice('C:\Users\raman\Documents\lalit.wma', 'Lalit')) #the matchvoice function will compare the voices
{
print "Lalit is present" }
else print "Lalit is absent"
v = Voiceid(db)
v.extract_speakers()
for c in v.get_clusters():
cluster = v.get_cluster(c)
print cluster
cluster.print_segments()
HOST_NAME = ''
#Porta do servidor
PORT_NUMBER = 9000
# A configuração: /dev/ttyACM0 é referente a porta USB que o Arduino esta ligado
ser = serial.Serial("/dev/ttyACM0", 9600)
ledLigado = "L".encode()
ledMais = "M".encode()
ledMenos = "m".encode()
fechadura = "F".encode()
tomada1 = "T".encode()
tomada2 = "t".encode()
#Configuracoes do banco de dados da API de voz
caminhoDB = '/home/smarthome/Banco/'
caminhoVoz = '/var/www/html/Voices/'
db = GMMVoiceDB(caminhoDB)
class MyHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
def do_GET(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
path = s.path
if '-' in path:
acao, nome, pessoa = path.split('-')
class Model:
""" Represents and manages all data model """
def __init__(self, test_mode=None):
self.voiceid = None
#self.db = GMMVoiceDB('/home/michela/SpeakerRecognition/voiceid/scripts/test_db/')
self.db = GMMVoiceDB(os.path.expanduser('~/.voiceid/gmm_db/'))
#self._cluster = None
#self._partial_record_time = 5
self.test_mode = test_mode
self.queue_processes = []
self._observers = []
self._processing_thread = None
self._queue_thread = []
self.thrd_n = 2
self._scores = {}
self.threshold = -32.160
def attach(self, observer):
""" Attach a new observer """
if not observer in self._observers:
self._observers.append(observer)
def detach(self, observer):
""" Deatach a new observer """
try:
self._observers.remove(observer)
except ValueError:
pass
def notify(self, modifier=None):
""" Notify an update """
for observer in self._observers:
if modifier != observer:
observer.update()
def save_callback(self, file_=None):
""" Adds a file to the queue after it's been saved """
if self.test_mode == True:
vid = Voiceid(self.db, file_, single=True)
self.queue_processes.append((vid, None))
def set_speaker_name(self, name, file_):
""" Adds speaker model in db """
shutil.move(file_, name + ".wav")
r = name + ".wav"
f = os.path.splitext(r)[0]
return self.db.add_model(str(f), name)
def alive_threads(self, t):
"""Check how much threads are running and alive in a thread dictionary
:param t thread dictionary
"""
num = 0
for thr in t:
if thr.is_alive():
num += 1
return num
def on_process(self, conf=1):
""" Extract speakers from each partial recording file """
while self.record.is_recording() or self.is_process_running():
index = 0
for vid, result in self.queue_processes:
if result == None:
if self.alive_threads(self._queue_thread) < self.thrd_n:
t = Thread(target=self.extract_speaker,
args=(vid, index, conf))
self._queue_thread.append(t)
self.queue_processes[index] = (vid, ['running'])
t.start()
else:
while self.alive_threads(
self._queue_thread) >= self.thrd_n:
time.sleep(1)
t = Thread(target=self.extract_speaker,
args=(vid, index, conf))
self._queue_thread.append(t)
self.queue_processes[index] = (vid, ['running'])
t.start()
index += 1
time.sleep(1)
def is_process_running(self):
if len(self.queue_processes) == 0: return True
for vid, result in self.queue_processes:
if result == None:
return True
return False
def get_last_result(self):
""" Return last result """
p = self.queue_processes[:]
p.reverse()
for file_, result in p:
if result != None and result[0] != "running":
return result
print "None last result!!"
return None
def start_record(self,
total_seconds=None,
partial_seconds=None,
stop_callback=None,
save_callback=None,
conf=1):
""" start a new record process """
self.queue_processes = []
if self.test_mode == True:
if conf == 1:
self.record = Record('',
total_seconds=total_seconds,
partial_seconds=partial_seconds,
stop_callback=stop_callback,
incremental_mode=True,
save_callback=self.save_callback)
elif conf == 2:
self.record = Record('',
total_seconds=total_seconds,
partial_seconds=partial_seconds,
stop_callback=stop_callback,
incremental_mode=False,
save_callback=self.save_callback)
else:
self.record = Record('',
total_seconds=partial_seconds,
partial_seconds=partial_seconds,
stop_callback=stop_callback,
incremental_mode=False,
save_callback=self.save_callback)
else:
self.record = Record('training',
total_seconds,
stop_callback=stop_callback,
save_callback=save_callback)
self.record.start()
self._processing_thread = Thread(target=self.on_process, args=(conf, ))
if self.test_mode == True: self._processing_thread.start()
def set_test_mode(self, mode):
""" Set mode to record - True for test mode False otherwise """
self.test_mode = mode
def get_test_mode(self):
""" Return mode to record - True for test mode False otherwise """
return self.test_mode
def stop_record(self):
""" Stop record process """
print "stop"
self.record.stop()
def get_process_status(self):
if self.test_mode == True:
q = self.queue_processes[:]
for file_, result in q:
if result == None or result[0] == 'running':
return False
return True
def extract_speaker(self, vid, index, conf):
""" Extract speaker from a wave """
vid.extract_speakers(quiet=True, thrd_n=16)
if conf == 1:
self.queue_processes[index] = (
vid, vid.get_cluster('S0').get_best_five())
elif conf == 2 or conf == 3:
last_scores = vid.get_cluster('S0').speakers
for i in last_scores:
if i in self._scores:
self._scores[i] += 60 + last_scores[i]
else:
self._scores[i] = 60 + last_scores[i]
self.queue_processes[index] = (vid,
sorted(self._scores.iteritems(),
key=lambda (k, v): (v, k),
reverse=True)[:5])
#print "extract finish",self.queue_processes[index]
#c= sorted(self._scores.iteritems(), key=lambda (k,v): (v,k),reverse=True)
#print c
self.notify()
class Model:
""" Represents and manages all data model """
def __init__(self, test_mode=None):
self.voiceid = None
# self.db = GMMVoiceDB('/home/michela/SpeakerRecognition/voiceid/scripts/test_db/')
self.db = GMMVoiceDB(os.path.expanduser("~/.voiceid/gmm_db/"))
# self._cluster = None
# self._partial_record_time = 5
self.test_mode = test_mode
self.queue_processes = []
self._observers = []
self._processing_thread = None
self._queue_thread = []
self.thrd_n = 2
self._scores = {}
self.threshold = -32.160
def attach(self, observer):
""" Attach a new observer """
if not observer in self._observers:
self._observers.append(observer)
def detach(self, observer):
""" Deatach a new observer """
try:
self._observers.remove(observer)
except ValueError:
pass
def notify(self, modifier=None):
""" Notify an update """
for observer in self._observers:
if modifier != observer:
observer.update()
def save_callback(self, file_=None):
""" Adds a file to the queue after it's been saved """
if self.test_mode == True:
vid = Voiceid(self.db, file_, single=True)
self.queue_processes.append((vid, None))
def set_speaker_name(self, name, file_):
""" Adds speaker model in db """
shutil.move(file_, name + ".wav")
r = name + ".wav"
f = os.path.splitext(r)[0]
return self.db.add_model(str(f), name)
def alive_threads(self, t):
"""Check how much threads are running and alive in a thread dictionary
:param t thread dictionary
"""
num = 0
for thr in t:
if thr.is_alive():
num += 1
return num
def on_process(self, conf=1):
""" Extract speakers from each partial recording file """
while self.record.is_recording() or self.is_process_running():
index = 0
for vid, result in self.queue_processes:
if result == None:
if self.alive_threads(self._queue_thread) < self.thrd_n:
t = Thread(target=self.extract_speaker, args=(vid, index, conf))
self._queue_thread.append(t)
self.queue_processes[index] = (vid, ["running"])
t.start()
else:
while self.alive_threads(self._queue_thread) >= self.thrd_n:
time.sleep(1)
t = Thread(target=self.extract_speaker, args=(vid, index, conf))
self._queue_thread.append(t)
self.queue_processes[index] = (vid, ["running"])
t.start()
index += 1
time.sleep(1)
def is_process_running(self):
if len(self.queue_processes) == 0:
return True
for vid, result in self.queue_processes:
if result == None:
return True
return False
def get_last_result(self):
""" Return last result """
p = self.queue_processes[:]
p.reverse()
for file_, result in p:
if result != None and result[0] != "running":
return result
print "None last result!!"
return None
def start_record(self, total_seconds=None, partial_seconds=None, stop_callback=None, save_callback=None, conf=1):
""" start a new record process """
self.queue_processes = []
if self.test_mode == True:
if conf == 1:
self.record = Record(
"",
total_seconds=total_seconds,
partial_seconds=partial_seconds,
stop_callback=stop_callback,
incremental_mode=True,
save_callback=self.save_callback,
)
elif conf == 2:
self.record = Record(
"",
total_seconds=total_seconds,
partial_seconds=partial_seconds,
stop_callback=stop_callback,
incremental_mode=False,
save_callback=self.save_callback,
)
else:
self.record = Record(
"",
total_seconds=partial_seconds,
partial_seconds=partial_seconds,
stop_callback=stop_callback,
incremental_mode=False,
save_callback=self.save_callback,
)
else:
self.record = Record("training", total_seconds, stop_callback=stop_callback, save_callback=save_callback)
self.record.start()
self._processing_thread = Thread(target=self.on_process, args=(conf,))
if self.test_mode == True:
self._processing_thread.start()
def set_test_mode(self, mode):
""" Set mode to record - True for test mode False otherwise """
self.test_mode = mode
def get_test_mode(self):
""" Return mode to record - True for test mode False otherwise """
return self.test_mode
def stop_record(self):
""" Stop record process """
print "stop"
self.record.stop()
def get_process_status(self):
if self.test_mode == True:
q = self.queue_processes[:]
for file_, result in q:
if result == None or result[0] == "running":
return False
return True
def extract_speaker(self, vid, index, conf):
""" Extract speaker from a wave """
vid.extract_speakers(quiet=True, thrd_n=16)
if conf == 1:
self.queue_processes[index] = (vid, vid.get_cluster("S0").get_best_five())
elif conf == 2 or conf == 3:
last_scores = vid.get_cluster("S0").speakers
for i in last_scores:
if i in self._scores:
self._scores[i] += 60 + last_scores[i]
else:
self._scores[i] = 60 + last_scores[i]
self.queue_processes[index] = (
vid,
sorted(self._scores.iteritems(), key=lambda (k, v): (v, k), reverse=True)[:5],
)
# print "extract finish",self.queue_processes[index]
# c= sorted(self._scores.iteritems(), key=lambda (k,v): (v,k),reverse=True)
# print c
self.notify()
if wav_file.find("##")==-1:
print "ERROR: MALFORMED WAV FILE ", wav_file
return False
ns=wav_file.split("##")[0]
if ns.split("_")==-1:
print "ERROR: MALFORMED WAV FILE ", wav_file
return False
return True
def get_simbol(wav):
tmp=wav.split("##")[0]
ns=tmp.split("_")
return ns[0]+ns[1]
if __name__ == '__main__':
all_wav =[]
for f in os.listdir(DIR_PATH):
if fnmatch.fnmatch(f, '*.wav') and f.find("##")>-1:
all_wav.append(f)
print all_wav
#all_wav=["/Users/labcontenuti/Documents/workspace/activevoice/voiceid/Talk_Radio##S10.wav"]
#all_wav=["/Users/labcontenuti/Music/Renato_Soru0##S0.wav"]
all_wav=["/Users/labcontenuti/Music/RenatoSoruS0.wav"]
db = GMMVoiceDB(DB_PATH)
for wav in all_wav:
#db.add_model(DIR_PATH+wav, get_simbol(wav))
db.add_model(wav, "RenatoSoru")
print "added ", wav
print "RND"
def showsp():
db = GMMVoiceDB('models')
spk= str(db.get_speakers())
out.insertHtml(QString("<font color=\"black\">%1</font>").arg(spk))
def showsp():
db = GMMVoiceDB('models')
spk = str(db.get_speakers())
out.insertHtml(QString("<font color=\"black\">%1</font>").arg(spk))
