def extract_rhythm_features(y, sr, song_name):
print('Start extract rythm ----- ')
sr, sw, y = audiofile_read(
'%s%s%s' % (settings.OUTPUT_PATH_WAV, '/', song_name + '.wav'))
features = rp_extract.rp_extract(
y, # the two-channel wave-data of the audio-file
sr, # the samplerate of the audio-file
extract_rp=True, # <== extract this feature!
transform_db=True, # apply psycho-accoustic transformation
transform_phon=True, # apply psycho-accoustic transformation
transform_sone=True, # apply psycho-accoustic transformation
fluctuation_strength_weighting=
True, # apply psycho-accoustic transformation
skip_leadin_fadeout=
1, # skip lead-in/fade-out. value = number of segments skipped
step_width=1)
print('Rhythm features loaded sucuccessfully: ')
print('len feature: ', len(features['rp']))
print(features)
# Create output folder if it's not exist
if not os.path.exists(settings.OUTPUT_PATH_HDF5):
os.makedirs(settings.OUTPUT_PATH_HDF5)
file_name = '%s_rhythm.hdf5' % song_name
file_path = '%s%s' % (settings.OUTPUT_PATH_HDF5, file_name)
data_file = h5py.File(file_path, 'w')
data_file.create_dataset('rhythm', data=features['rp'])
data_file.close()
print('Store Rhythm features Sucessfully: ---------------')
# upload MFCC to AWS S3
upload_file(file_path, file_name, settings.BUCKET_HDF5)
n_fft=512,
hop_length=256)
spectral_flatness = librosa.feature.spectral_flatness(y=y,
n_fft=512,
hop_length=256)
spectral_rolloff = librosa.feature.spectral_rolloff(y=y,
sr=sr,
n_fft=512,
hop_length=256)
zero_crossings = librosa.feature.zero_crossing_rate(y=y)
chromagram_cens = librosa.feature.chroma_cens(y=y, sr=sr)
tonnetz = librosa.feature.tonnetz(y=y, sr=sr)
ssd_rp = rp_extract.rp_extract(wavedata=y,
samplerate=sr,
extract_ssd=True,
extract_rp=True)
ssd = ssd_rp.get('ssd')
rp = ssd_rp.get('rp')
tempo = librosa.beat.tempo(y=y, sr=sr)
to_append += f' {np.mean(spectral_centroid)} {np.std(spectral_centroid)} {np.mean(np.diff(spectral_centroid))} {np.std(np.diff(spectral_centroid))}'
to_append += f' {np.mean(spectral_bandwidth)} {np.std(spectral_bandwidth)} {np.mean(np.diff(spectral_bandwidth))} {np.std(np.diff(spectral_bandwidth))}'
to_append += f' {np.mean(spectral_contrast)} {np.std(spectral_contrast)} {np.mean(np.diff(spectral_contrast))} {np.std(np.diff(spectral_contrast))}'
to_append += f' {np.mean(spectral_flatness)} {np.std(spectral_flatness)} {np.mean(np.diff(spectral_flatness))} {np.std(np.diff(spectral_flatness))}'
to_append += f' {np.mean(zero_crossings)} {np.std(zero_crossings)} {np.mean(np.diff(zero_crossings))} {np.std(np.diff(zero_crossings))}'
for mfcc in mfccs:
to_append += f' {np.mean(mfcc)} {np.std(mfcc)} {st.skew(mfcc)} {st.kurtosis(mfcc)}'
def organizarDados(path, destino, audios):
print("Organizando dados")
# Diretórios usados para consulta da base e criação dos folds
dir_origem = path
dir_gravacoes = dir_origem
dir_origem += destino
dir_gravacoes += 'audios_gravados'
cont_audios = audios
# Onde serão armazenados os arquivos gerados (mesma estrutura de divisão)
numPessoas = 5
# Lista os arquivos da pasta e ordena
conteudo = os.listdir(dir_origem)
conteudo = natural_sort(conteudo)
nome_audio = os.listdir(dir_gravacoes)
nome_audio = natural_sort(nome_audio)
sys.path.append('./rp_extract')
tipos_feat = {'rh': False, 'rp': False, 'ssd': True}
#dir_treino = dir_destino+'treino-'+bases[decisao]+'.txt'
dir_treino = "arquivos_treino/"
bases_treino = os.listdir(dir_treino)
dir_treino += bases_treino[0] + '/treino-{}.txt'.format(destino)
print("Extraindo dados do áudio: ")
for i in range(5):
print('{}.wav'.format(cont_audios + 1))
dir_extracao = dir_gravacoes + '/{}.wav'.format(cont_audios + 1)
wavedata, samplerate = librosa.load(dir_extracao, sr=44100)
feat = rp_extract.rp_extract(wavedata,
samplerate,
extract_rp=tipos_feat['rp'],
extract_ssd=tipos_feat['ssd'],
extract_rh=tipos_feat['rh'])
cont_audios += 1
# Verifica cada uma dos três tipos de features acústucas
for t in tipos_feat:
# Se estiver definido como true, guarda as características num arquivo
if tipos_feat[t]:
nome_arq_feat = dir_treino
# Abre o arquivo com as características
arquivo_feat = open(nome_arq_feat, 'a')
# Grava cada uma das características no arquivo na pasta de destino, conforme seu tipo
for f in feat[t]:
print("f: ", f)
arquivo_feat.write("%f " % f)
# Escreve o nome do arquivo e pula uma linha
arquivo_feat.write("\n")
# Fecha o arquivo
arquivo_feat.close()
atual = 0
#print(audios)
for pastas in range(int(audios / 5), int(len(conteudo) + 1)):
# Não esquece de adicionar a barra pra direita no final do caminho
cont = 0
print(pastas)
dir_destino = dir_origem + '/' + 's' + str((pastas) + 1) + '/'
if not os.path.exists(
dir_destino
): #Cria as pastas s1, s2, ... , sn caso não existam
os.makedirs(dir_destino)
for i in range(5):
dir_pessoas = dir_gravacoes + '/' + nome_audio[atual]
atual += 1
if cont < numPessoas:
shutil.move(dir_pessoas, dir_destino)
cont += 1
def extrair_audio():
print("Deseja extair quais dados?")
dir_extracao = 'PIBITI/'
id_base = []
total_dir = len(os.listdir(dir_extracao))
bases = os.listdir(dir_extracao)
#print(len(os.listdir(dir_extracao)))
for i in range(total_dir):
print("{} - {}".format(i, bases[i]))
id_base.append(i)
decisao = int(input())
print(bases[decisao])
#####################################################################
# Diretórios usados para consulta da base e criação dos folds
dir_origem = 'PIBITI/'
dir_origem += bases[decisao]+'/'
# Onde serão armazenados os arquivos gerados (mesma estrutura de divisão)
dir_destino = 'arquivos_treino/'
dir_destino += 'caracteristicas-'+bases[decisao]+'/'
dir_arq = dir_destino+'treino-'+bases[decisao]+'.txt'
if not os.path.exists(dir_destino):
print("Criando pasta para guardar arquivo de características")
os.mkdir(dir_destino)
else:
print("Limpando pasta")
shutil.rmtree(dir_destino)
os.mkdir(dir_destino)
# Vai para a pasta do framework
sys.path.append('./rp_extract')
# os.chdir('./rp_extract')
from audiofile_read import *
from rp_extract import rp_extract
tipos_feat = {'rh' : False, 'rp' : False, 'ssd': True}
total_pessoas = len(os.listdir(dir_origem))
cont_amostras = 0
for pessoa in range(1, total_pessoas+1):
for amostras in range(1,6):
cont_amostras += 1
dir_extracao = dir_origem+'s{}/'.format(pessoa)+'{}.wav'.format(cont_amostras)
print("Extraindo de {}.wav".format(cont_amostras))
wavedata, samplerate = librosa.load(dir_extracao, sr=44100)
feat = rp_extract.rp_extract(wavedata, samplerate, extract_rp=tipos_feat['rp'], extract_ssd=tipos_feat['ssd'], extract_rh=tipos_feat['rh'])
# Verifica cada uma dos três tipos de features acústucas
for t in tipos_feat:
# Se estiver definido como true, guarda as características num arquivo
if tipos_feat[t]:
nome_arq_feat = dir_arq
# Abre o arquivo com as características
arquivo_feat = open(nome_arq_feat, 'a')
# Grava cada uma das características no arquivo na pasta de destino, conforme seu tipo
for f in feat[t]:
print("f: ",f)
arquivo_feat.write("%f " % f)
# Escreve o nome do arquivo e pula uma linha
arquivo_feat.write("\n")
# Fecha o arquivo
arquivo_feat.close()
print("Terminado, arquivo salvo em {}".format(dir_arq))
def extrair_e_converter():
sys.path.append('./rp_extract')
tipos_feat = {'rh' : False, 'rp' : False, 'ssd': True}
print("Extraindo dados do áudio gravado")
wavedata, samplerate = librosa.load(dir_entrada_teste, sr=44100)
feat = rp_extract.rp_extract(wavedata, samplerate, extract_rp=tipos_feat['rp'], extract_ssd=tipos_feat['ssd'], extract_rh=tipos_feat['rh'])
# Verifica cada uma dos três tipos de features acústucas
for t in tipos_feat:
# Se estiver definido como true, guarda as características num arquivo
if tipos_feat[t]:
nome_arq_feat = dir_arq+'.txt'
# Abre o arquivo com as características
arquivo_feat = open(nome_arq_feat, 'w')
# Grava cada uma das características no arquivo na pasta de destino, conforme seu tipo
for f in feat[t]:
print("f: ",f)
arquivo_feat.write("%f " % f)
# Escreve o nome do arquivo e pula uma linha
arquivo_feat.write("\n")
# Fecha o arquivo
arquivo_feat.close()
print("convertendo para entrada libSVM")
dir_conversao = r"arquivos_teste"
extensao_txt = ".txt"
nome_txt = [_ for _ in os.listdir(dir_conversao) if _.endswith(extensao_txt)]
file_conversao = open(r"{}".format(dir_conversao) + r"\{}".format(nome_txt[0]), 'r')
conteudo = file_conversao.readlines()
conteudo = natural_sort(conteudo)
file_conversao.close()
pessoa = 1
cont = 1
train_feat = []
train_label = []
for linha in range(len(conteudo)):
# A cada 5 amostras troca-se a pessoa
if linha > 0 and linha % 5 == 0:
pessoa += 1
cont = 1
# Usa no treinamento se o cont for até a quantidade de amostras para treino
np.array(train_feat.append(conteudo[linha].split()))
train_label.append(str(pessoa))
cont += 1
x = np.array(train_feat)
treino = dir_conversao+r'\convertido-audio_extraido.svm'
fileTreino = open(treino,"w")
conteudoTreino = x
linhas = len(conteudoTreino)
colunas = len(conteudoTreino[0])
cont = 0
for i in range(linhas):
cont = 1
fileTreino.write("{} ".format(train_label[i]))
for j in range(colunas):
fileTreino.write("{}:{} ".format(cont, conteudoTreino[i][j]))
cont += 1
fileTreino.write("\n")
fileTreino.close()