Reconhecimento de Locutor
Felipe Vicente Rodrigues
Engenharia de Computao
Universidade Tecnolgica Federal do Paran
Cornlio Procpio, Paran, Brasil
feliperodrigues@alunos.utfpr.edu.br
Murillo Antoniazzi da Silva
Engenharia de Computao
Universidade Tecnolgica Federal do Paran
Cornlio Procpio, Paran, Brasil
muuantoniazzi@gmail.com
I. INTRODUO
O principal objetivo deste projeto aplicar o conhecimento
adquirido atravs da disciplina de Processamento Digital de
Sinais, para a criao de um sistema que seja capaz de
reconhecer padres e determinar quem o locutor a partir de
amostras de udio dos 4 membros do grupo.
A rea de reconhecimento de voz extremamente
abrangente. Se, at certo tempo, a ideia de realizar tarefas
atravs de um simples comando de voz era vista como algo
futurista, atualmente somos capazes de encontrar diversas
dessas aplicaes que visam facilitar o dia-a-dia das pessoas.
Um bom exemplo disso so as ferramentas de pesquisas por
voz, presentes em grande parte dos smartphones e
computadores atuais, nesse caso, o sistema deve ser capaz de
reconhecer as palavras informadas pelo locutor para realizar a
ao ordenada.
Existe tambm a questo da incluso, onde pessoas com os
mais variados tipos de deficincias, podem realizar
determinadas tarefas, at ento impossveis, utilizando
comandos de voz.
Entre as diversas vantagens do uso de tais sistemas,
destaca-se a facilidade e rapidez de realizar uma ao mesmo
realizando outras atividades. Alm de tratar-se de um dos
mtodos menos invasivo, que no precisa de grande
quantidade de recursos de hardware, apena um microfone. [1]
Uma evidente desvantagem nesse tipo de sistema a
necessidade de maior quantidade de amostras para obter uma
boa qualidade no resultado. Comparado ao sistema biomtrico
por impresso digital, onde necessrio que o usurio tenha uma quantidade menor de treinamento, porm mais restrito
seu dedo escaneado apenas uma vez, o sistema por voz requer
uma maior quantidade de entradas para assegurar a veracidade
do reconhecimento. [1]
Embora muito til, esse tipo de sistema requer uma srie
de cuidados e tratamentos para garantir um bom
funcionamento, principalmente em servios onde existe um
maior risco, tais como, comandos em automveis ou sistemas
Lucas Buzetto Tsuchiya
Engenharia de Computao
Universidade Tecnolgica Federal do Paran
Cornlio Procpio, Paran, Brasil.
lucastsuchiya@alnos.utfpr.edu.br
Vitor Vinicius Gomes da Silva
Engenharia de Computao
Universidade Tecnolgica Federal do Paran
Cornlio Procpio, Paran, Brasil.
vitor.vinicius.gs@gmail.com
de segurana. Trabalhar com sinais de voz pode ser algo muito
complexo para um sistema, dependendo da quantidade de
interferncia que esse sinal possui.
Entre os diversos tipos de reconhecimento de voz, existe o
Reconhecimento de Locutor, que se trata do objetivo proposto
neste projeto. Nesse caso, o sistema deve ser capaz de
reconhecer um padro, para que, no reconhea apenas a
palavra que est sendo falada, mas tambm identifique quem a
est falando. Esse tipo de sistema pode ser usado, por
exemplo, em um sistema de segurana, que s realiza aes
quando reconhece a palavra certa vinda de um locutor vlido.
O sistema de reconhecimento de locutor pode ser
separado em dois modelos: Os dependentes de palavras e os
independentes de palavras.
Nos sistemas independentes de palavras, o
reconhecimento no depende de palavras armazenadas em um
banco de dados e sim das caractersticas da voz de locutor. A
entrada praticamente no possui restries no contedo da
fala[2]. Porm, para garantir uma boa preciso necessria
uma maior quantidade de amostras, de modo que as
caractersticas do locutor sejam extradas da melhor maneira
possvel.
J no sistema dependente de palavra, no qual o
projeto foi baseado, so coletadas e armazenadas previamente
em um banco de dados, uma sequncia de palavras que sero
utilizadas para treinar o sistema. O reconhecimento nesse tipo
de sistema dependente de dois fatores principais: A voz deve
ser reproduzida por um locutor vlido e o locutor deve
fornecer uma palavra apropriada[3]. A entrada de voz deve ser
igual a um dos contedos armazenados[2]. Esse sistema requer
comparado aos sistemas independentes de palavras.
Para a realizao do projeto, foram colhidas algumas
amostras de udio onde cada participante do grupo repetiu
palavras pr-determinadas por 10 vezes, porm, constatou-se
que as amostras sofriam com interferncias externas e no
possuam uma boa qualidade devido ao uso de um microfone
mais simples. Para evitar novos problemas, foram colhidas
novas amostras, dessa vez em um ambiente devidamente Dados da Matriz X: a matriz de dados, cada linha
isolado alm da utilizao de um microfone de melhor contm uma observao e cada coluna contm uma varivel
qualidade. destacada.
Respostas Y: o vetor de respostas, com o mesmo nmero
de observaes que as linhas em X.
II. FUNDAMENTAO TERICA Mtodo Ensemble: uma string com o nome do tipo do
ensemble. (Subspace)
A. Ensemble
Number of weak Learners in Ensemble: Nmero de
classificadores.
Com a extrao das caractersticas do sinal de udio dos Weak Learner: Algoritmo de Aprendizagem.
locutores, gera-se um grande volume de dados digitais, com
isso surge a necessidade de aplicao de tcnicas de A figura abaixo mostra o trecho do cdigo do
inteligncia artificial para a classificao e o reconhecimento desenvolvimento do projeto, utilizando a funo fitensemble.
de padres. Para o desenvolvimento do sistema de
reconhecimento de locutor, foi utilizado o Ensemble da
Toolbox do Matlab.
O Ensemble um conjunto de classificadores que
consistem em uma coleo de vrios outros classificadores,
cuja decises individuais so combinadas de determinada
maneira a fim de melhor classific-los [4]. A ideia do
ensemble utilizar classificadores com pouco poder de
generalizao, que podem ter seu desempenho melhorado
quando utilizado na forma de comit sobre uma massa de
dados [4]. O Ensemble utiliza vrios classificadores com
algoritmos de aprendizado de mquina como o KNN. O KNN
um mtodo baseado em instncia que aprende como o
simples armazenamento dos dados de treinamento. Quando
uma nova instncia surge, ele recupera os dados em memria e
classifica essa nova instncia. A partir dos k vizinhos mais Figure 2 - Funo fitensemble.
prximos instncia que ser classificada, o algoritmo avalia
a classe predominante e atribui essa classe nova instncia
[5]. No trabalho, foi aplicado o Ensemble subspace KNN, pois
dentre os classificadores de padro, foi o que deu o maior B. Implementao
valor de acurcia, cerca de 94.1 %.
Segundo a documentao da MathWorks, o mtodo
ensemble consiste em fundir resultados de muitos A implementao em software para o reconhecimento de
classificadores fracos, com pouco poder de generalizao em locutor foi dividida em quatro etapas: Pr-processamento,
um preditor ensemble de alta qualidade. Esses mtodos Extrao de Caractersticas usando Wavelets, Treinamento e
seguem com pequenas alteraes em seus comandos. Neste Classificao e Teste.
caso, possvel criar um conjunto para classificao ou
regresso usando fitensemble. A figura abaixo mostra as C. Pr-Processamento
principais informaes para criar um ensemble:
Nesta etapa, o sinal de voz do locutor conta com rudos do
ambiente e longos intervalos de silncio. O silncio pode ser
entendido como faixas do sinal discreto de voz em que a
amplitude muito prxima zero, mas que ainda esto
associadas a frequncias presentes no sinal. Entende-se por
rudo toda caracterstica presente no sinal que no faz parte da
voz do locutor, por exemplo: fala cruzada, sons de animais,
som de mquinas em operao e interferncias
eletromagnticas.
O objetivo desta etapa remover do sinal a maior
quantidade de silncio e rudo possvel. Para isto, as amostras
de voz para alimentar o banco de dados e as amostras de voz
de teste foram capturadas frequncia de amostragem de 6800
Figure 1 Ensemble. Hz e submetidas a filtros passa-faixas de Butterworth (Anexo
III) para extrair do sinal apenas o que estiver entre 50 Hz e
3400 Hz (que a faixa de frequncia caracterstica da voz
humana). Em seguida, para eliminar o rudo, foi aplicado nos
sinais de voz, j tratados anteriormente, um filtro removedor
de rudo baseado na anlise de Wavelets que minimiza o nvel
de rudo do sinal e o prepara para o prximo filtro que ir
remover o silncio. O cdigo fonte deste filtro est disponvel
no Anexo I.
Com o sinal livre de rudos, foi a aplicado um filtro que
remove o mximo de silncio possvel do sinal. Este filtro foi
desenvolvido por Theodoros Giannakopoulos e se baseia na
deteco de voz em segmentos do sinal, ou seja, o sinal
segmentado em regies e nestas regies so detectadas
caractersticas da voz humana e do ambiente como energia e
centride espectral para determinar se a regio pode ser
includa ou no no sinal resultante. Maiores detalhes sobre o
funcionamento deste filtro podem ser encontrados no artigo
A method for silence removal and segmentation of speech
signals, implemented in Matlab publicado por
Giannakopoulos. O cdigo fonte do filtro removedor de
silncio encontra-se disponvel no Anexo II.
D. Wavelets
Visando extrair caractersticas dos sinais, utilizaremos as
transformadas wavelets. As transformadas wavelets, so um
mecanismos para decompor ou quebrar sinais nas suas partes
constituintes, permitindo ter uma anlise de dados em
diferentes domnios de frequncia. Alm disso na anlise de
wavelets, possvel usar funes que esto contidas em
regies finitas, tornando as convenientes na aproximao de
dados com descontinuidades.
As transformadas wavelets podem ser representadas por
uma rvore de decomposio da transformada wavelet.
Abaixo uma imagem como exemplo de uma rvore de
decomposio da transformada wavelet.
Figure 3 - rvore de decomposio da transformada wavelet.
A decomposio feita em multi-nveis, cada nvel possui
metade da frequncia do tempo e comprimento do nvel
superior, a decomposio podo ser feita utilizando filtros
passa-baixas e passa-altas.
E. Wavelet Packet
Wavelet Packets a generalizao da decomposio
wavelet, retorna uma melhor anlise do sinal. So
interpretadas por trs parmetros: posio, escala e frequncia.
Utiliza os coeficientes de cada folha da rvore gerada pela
decomposio wavelet para construir propriedades e variveis
que podem representar uma classe(locutor).
A base de seleo identifica a melhor base que pode
identificar com preciso as caractersticas de uma determinada
classe.
F. Extrao de Caractersticas usando Wavelets
Com o sinal pr-processado, tem-se a necessidade de
extrair do mesmo as caractersticas que podem identificar a
pessoa no dilogo presente no sinal. Existem diversas
caractersticas que podem distinguir uma pessoa atravs de sua
voz, por exemplo: timbre, perodo de pitch e formantes. Neste
trabalho, a extrao de caractersticas foi feita usando a
transformada Wavelet e se baseou no trabalho realizado por
Khushaba et al no artigo Driver Drowsiness Classification
Using Fuzzy Wavelet Packet Based Feature Extraction
Algorithm. No artigo, Khushaba e demais, procuraram
classificar a sonolncia e a perda de ateno de condutores por
meio de extrao de caractersticas usando Wavelet Packet de
sinais de eletroencefalogramas e lgica Fuzzy baseadas na
construo de caractersticas e bases de seleo utilizando um
algoritmo criado pela equipe da pesquisa. A fase da
construo de caractersticas se baseia na utilizao dos
coeficientes de cada folha da rvore gerada pela decomposio
Wavelet para construir propriedades e variveis que podem
representar uma classe (que a identificao de um indivduo
ou, no caso deste trabalho, um locutor). J a fase das bases de
seleo se baseia na identificao da melhor base (usando um
conjunto de bases) que pode identificar com preciso
caractersticas de uma determinada classe. As duas fases se
baseiam nos trabalhos de Coifman e Wickerhauser que
propuseram um mtodo que utiliza a entropia de Shannom
para a seleo de bases e no trabalho de Saito que desenvolveu
um algoritmo para selecionar bases utilizando entropia
relativa.
Para cada nvel e subnvel, considerados como espaos de
caractersticas, da decomposio Wavelet do sinal pr-
processado calculada a soma dos quadrados dos coeficientes
do subnvel dividida pelo nmero N de coeficientes do
subnvel. A partir disto, calculado o logaritmo do valor
obtido, obtendo assim a energia logartmica normalizada
Ej,k do subnvel j,k calculada no sobre os coeficientes.
Este clculo melhor representado na Equao 1, abaixo:
Figure 4 Equao 1.
 Como pode ser visto na equao anterior, Ej,k uma
matriz de energias que representam as caractersticas
desejveis do sinal transformado. No artigo de Khushaba et al,
aps obter esta matriz aplicado sob ela um conjunto de
ponderaes utilizando a lgica Fuzzy. Este conjunto de
ponderaes esto disponveis em maiores detalhes no artigo.
A matiz obtida pode ser assim utilizada como um conjunto de
caractersticas que identificam uma classe.
Para utilizar o algoritmo disponibilizado online por
Khushaba neste projeto de reconhecimento de locutor, foi
necessrio adapt-lo para extrair somente caractersticas do
ltimo nvel da transformada Wavelet. Essa adaptao foi feita
conforme as instrues deixadas pelo autor no artigo Feature
Extraction Using Multisignal Wavelet Packet (WP)
Decomposition. O algoritmo modificado est disponvel no
Anexo III.
G. Treinamento e Classificao
Obtidas as caractersticas do sinal de voz de um locutor, se
faz necessrio que um classificador estatstico seja utilizado
para relacionar essas caractersticas com a classe do locutor.
Dentre os diversos classificadores estatsticos disponveis, o
Ensemble foi escolhido pois apresentou melhor acurcia de
classificao mediante o baixo nmero de amostras recolhidas
para teste e classificao, cerca de 94%.
Nesta etapa, todos os intrigantes do projeto foram usados
como locutores para aquisio de amostras de treinamento.
Sabendo a classe do locutor e obtido sua matriz de
caractersticas, esses dados foram enviados para o
classificador para treinamento. A funo utilizada para isto foi
o mtodo trainClassifier(...) que recebe como entrada uma
matriz 17xN onde a primeira coluna representa as classes, as
16 outras colunas representam as caractersticas de cada
locutor e N o nmero de linhas da matriz e retorna um
classificador treinado e a acurcia da classificao. Um
exemplo desta matriz de entrada pode ser na tabela 1, que se
encontra no apndice de tabelas.
Obtido um classificador treinado, ele salvo em arquivo
para ser utilizado posteriormente na etapa de teste e
classificao.
H. Teste
A etapa de teste consiste em utilizar o classificador
treinado para classificar o locutor de um sinal de voz pr-
processado. Obtm-se uma matriz de caractersticas do sinal
de teste que enviada como parmetro para o classificador. O
classificador ter o trabalho de comparar as caractersticas
desta matriz com o que ele aprendeu na etapa de treinamento
para ento classificar quais classes pertencem as
caractersticas da matriz. O resultado deste processo dada na
forma de outra matriz que relaciona cada linha de
caracterstica da matriz de entrada da funo com uma classe
identificada. Sendo assim, a classe que mais se repetir na
matriz de sada, a classe identificada. A funo responsvel
por processar a matriz de entrada o mtodo predictFcn(...)
presente na estrutura de dados do classificador. Esta funo foi
utilizada na funo reconhecerLocutor(...) que recebe como
entrada o sinal de udio do locutor, processa o sinal, extrai
caractersticas e classifica o locutor retornando como respostas
a classe identificada e a acurcia da identificao ou o valor
-1 caso a funo no identifique nenhum locutor
compatvel(Miss). As duas funes mencionadas esto
disponveis nos anexos deste trabalho.
I. Base de Dados
A base de dados do sistema armazena as amostras de udio
que foram usadas para treinamento do classificador, as
configuraes de durao de gravao e o classificador
treinado na forma de arquivos que so gerados dinamicamente
com o uso da aplicao pelo usurio.
J. Programa
Ao executar, utilizando o software MATLAB, o arquivo
main.m, exibido um menu o qual o usurio pode escolher
entre: inserir uma amostra de udio para treinamento pelo
microfone; inserir uma amostra de udio para treinamento a
partir de um arquivo WAVE; reconhecer um locutor a partir
do microfone; reconhecer um locutor a partir de um arquivo
WAVE; e, treinar manualmente o classificador para exibir a
acurcia.
Optando por inserir amostras, ser necessrio que o
usurio entre com a durao do udio para gravao pelo
microfone ou o nome do arquivo WAVE que ser includo na
base de dados. Se o usurio optar por reconhecer o locutor,
ser necessrio fornecer o nome do arquivo WAVE que
contm a amostra de udio ou que o computador contenha um
microfone conectado para que seja capturado a amostra de
teste por ele.
K. Teste de classificao
Os testes de classificao foram feitos com base em
amostras de udio dos locutores reservadas para teste. Essas
amostras estavam armazenadas na base de dados do sistema.
As amostras de teste e de treinamento foram obtidas em um
estdio de gravao parcialmente livre de rudos no interior do
campus da UTFPR-CP.
L. Casos de Teste
Foram elaborados casos de testes para verificar se o
comportamento do sistema quando ele submetido locutores
falando a mesma palavra e quando os locutores falam palavras
aleatoriamente. Os casos de testes escolhido esto
relacionados a seguir:
 Classificador treinado com palavra 'teste' e verificada com
palavra 'teste'
Classificador treinado com palavra 'teste' e verificada com IV. REFERNCIAS
palavras aleatrias
Classificador treinado com palavras aleatrias e verificada [1] Niedu, Guilherme. Biometria Impresso Vocal:
com palavra 'teste' https://www.gta.ufrj.br/grad/08_1/bio-voz/Locutor.html
Classificador treinado com palavras aleatrias e verificada [2] Zhang, Zhengyou. Speaker Verification: Text-Dependent vs. Text-
Independet: https://www.microsoft.com/en-us/research/project/speaker-
com palavras aleatrias verification-text-dependent-vs-text-independent/
[3] Rodrguez, David Sierra, Text-Independent Speaker Identification:
http://www.dsp.agh.edu.pl/_media/pl:thesis.pdf
M. Estatsticas
[4] Pinheiro, M.Hedenir. Aplicao de Ensembles de Classificadores na
Deteco de Patologia na Coluna Vertebral Instituto de Informtica
Com os testes realizados com base nos quatro casos de Universidade Federal de Gois.
teste citados anteriormente, foram obtidas estatsticas de [5] Vriesamnn L.M; "Seleco Dinmica de subconjunto de classificadores:
Abordagem baseada em Acurcia Local". Curitiba, pg 50-70, 2012.
reconhecimento de locutores pelo sistema. As estatsticas
[6] denoiseEm.m :
foram organizadas na forma de tabelas e levam em http://www.kelidestan.com/forum/showthread.php?tid=4443&pid=6714
considerao os acertos do classificador, os erros e quando o [7] A method for silence removal and segmentation of speech signals,
classificador no foi capaz de classificar um locutor (Miss, ou implemented in Matlab:
-1), como pode ser visto no apndice de tabelas. https://www.mathworks.com/matlabcentral/fileexchange/28826-silence-
removal-in-speech-signals
[8] Feature Extraction Using Multisignal Wavelet Packet(WP)
III. ANLISE DOS RESULTADOS Decomposition:
https://www.mathworks.com/matlabcentral/fileexchange/28826-silence-
removal-in-speech-signals
Para compreender as tabelas a base de dados possui quatro [9] NALON, Jos Alexandre. Introduo ao processamento digital de sinais.
locutores, sendo cada locutor classificado como uma classe, Rio de Janeiro, RJ: LTC, 2009. 200 p. 130-153.
sendo locutor um chamado de classe um, locutor dois, classe [10] P. C. de Lima, Wavelets: uma introduo, Matemtica Universitria,
vol. 33, pp. 1344, 2002.
dois e assim por diante at o locutor quatro classe quatro. A
[11] RUSSEL, Stuart J. NORVIG, Peter. Inteligncia Artificial. Rio de
classificao miss indica que o classificador no foi capaz de Janeiro, RJ: Elsiever, 2013. P. 795-800.
classificar. [12] MathWorks Documentation, disponvel em:
De acordo com a tabela II, cada locutor pronunciou cinco https://www.mathworks.com/help/wavelet/ug/wavelet-packets.html.
vezes a palavra teste para popular a base de dados e fazer o Acessado em 18 de junho de 2017.
treinamento. Para verificar o treinamento foi comparado com a
mesma palavra, do total de vinte dados, o treinamento resultou
em dezesseis acertos, dando uma margem de 80% de acerto,
dois erros(10 %) onde classificou o locutor dois como se fosse
o locutor trs e teve dois miss(10%).
O resultado miss que surgiu apenas no locutor um
provvel que seja pela entonao da voz do locutor onde deu
para notar que cada seu tom de voz foi diferente para cada um
dado gravado.
O segundo caso, referente a tabela III, a base foi treinada
com a palavra teste para classificar foi comparado com
palavras aleatrias.
O acerto foi de apenas 20%, erro de 10% e 70% de miss.
O terceiro caso, referente a tabela IV, a base foi treinada
com palavras aleatrias e verificada com a palavra teste, o
resultado foi de 25% de acerto, 70% de erro e 5% de miss.
O quarto caso, referente a tabela V, a base foi treinada com
palavras aleatrias e verificada com palavras aleatrias, o
resultado foi de 25% de acerto, 55% de erro e 20% de miss.
De acordo com os resultados notamos que o sistema de
reconhecimento de locutor dependente de palavra, com isso
o nvel de confiana e preciso muito baixo, no sendo
seguro para ser utilizado. O sistema deve ocorrer melhorias
para ser independente de palavra, para isso o extrator de
caractersticas precisa ser aprimorado.
Para projetos futuros recomendvel utilizar a MFCC(Mel
Frequency Cepstral Coefficients) no lugar de wavelets.
 V. APNDICE DE TABELAS 4 4 Sim
4 4 Sim
Table 1 Caractersticas dos locutores
Caractersticas 4 4 Sim
Classe
C1 C2 C3 C4 ... C16 Acertos: 16
-
%Acertos: 80
4 -8,66 -8,92 10,05 -9,22 ... -9,85
4 -9,02 -9,16 -9,76 -9,19 ... -10,21 Miss: 2
- %Miss: 10
2 -8,63 -9,39 10,34 -9,26 ... -10,32
-
2 -9,83 -10,07 11,01 -10,45 ... -11,03 Table 3 - Teste - Aleatrias
- 2 Caso: base treinada com palavra 'teste' e
3 -9,55 -10,06 11,03 -10,49 ... -11,07 verificada com palavras aleatrias
- -
3 10,01 -10,23 11,22 -10,53 ... -11,10
-
1 -9,35 -10,14 11,41 -10,96 ... -11,46 Locutor
- Acerto
Esperado Obtido
1 -9,32 -10,15 11,31 -10,93 ... -11,34
N ... ... ... ... ... ... 1 -1 No
1 -1 No

Table 2 - Teste-Teste 1 -1 No
1 Caso: Base treinada com palavra 'teste' e 1 2 No
verificada com palavra 'teste'
1 -1 No
Locutor 2 -1 No
Acerto
Esperado Obtido 2 -1 No

1 -1 No 2 -1 No

1 1 Sim 2 2 Sim

1 -1 No 2 2 Sim

1 1 Sim 3 -1 No

1 1 Sim 3 2 No

2 3 No 3 -1 No

2 2 Sim 3 -1 No

2 2 Sim 3 -1 No

2 2 Sim 4 -1 No

2 3 No 4 4 Sim

3 3 Sim 4 4 Sim

3 3 Sim 4 -1 No

3 3 Sim 4 -1 No

3 3 Sim Acertos: 4

3 3 Sim %Acertos: 20

4 4 Sim Miss: 14

4 4 Sim %Miss: 70
 Table 5 - Aleatrias - Aleatrias
4 Caso: base treinada com palavras aleatrias e
Table 4 - Aleatrias - Teste verificada com palavras aleatrias
3 Caso: base treinada com palavras aleatrias e
verificada com palavra 'teste'

Locutor
Acerto
Locutor Esperado Obtido
Acerto 1 4 No
Esperado Obtido
1 -1 No
1 4 No
1 -1 No
1 4 No
1 -1 No
1 4 No
1 4 No
1 4 No
2 4 No
1 4 No
2 4 No
2 4 No
2 4 No
2 4 No
2 4 No
2 4 No
2 4 No
2 4 No
3 4 No
2 -1 No
3 4 No
3 4 No
3 4 No
3 4 No
3 4 No
3 4 No
3 -1 No
3 4 No
4 4 Sim
3 4 No
4 4 Sim
4 4 Sim
4 4 Sim
4 4 Sim
4 4 Sim
4 4 Sim
4 4 Sim
4 4 Sim
Acertos: 5
4 4 Sim
%Acertos: 25
Acertos: 5
Miss: 4
%Acertos: 25
%Miss: 20
Miss: 1
%Miss: 5
 VI. ANEXO DE CDIGOS [y, cxc, lxc, perf0, perfl2]=wdencmp( 'gbl' ,x, 'db3'
,2,thr,sorh,keepapp);

A. Anexo I
B. Anexo II
function y = filtrar(y)
Fs=6800; function [segments, fs] = detectVoiced(x,fs,t)

%filtro passa-faixas %
N = 3; % function [segments, fs] = detectVoiced(wavFileName)
fc1 = 50; fc2 = 3399.99; %
wc = (2 * [fc1 fc2])/Fs; % Theodoros Giannakopoulos
[P,Q] = butter(N,wc,'bandpass'); % http://www.di.uoa.gr/~tyiannak
y = filter(P,Q,y); %
% (c) 2010
%filtro de ruido %
y = denoiseEm(y); % This function implements a simple voice detector. The
algorithm is
% described in more detail, in the readme.pdf file
%removedor de silencio %
y = cell2mat( detectVoiced(y,Fs)); % ARGUMENTS:
% - wavFileName: the path of the wav file to be analyzed
% %filtro de mdia mvel % - t: if provided, the detected voiced segments are played
% P = (1/N)*ones(1,N); and some
% Q = 1; % intermediate results are also ploted
% y = filter(P,Q,y); %
% sound(y,Fs); % RETURNS:
% pause(2); % - segments: a cell array of M elements. M is the total
number of
% detected segments. Each element of the cell array is a
% %filtro envelope rms vector of audio
% wl = 30; % samples of the respective segment.
% [up,down] =envelope(y,wl,'rms'); % - fs: the sampling frequency of the audio signal
% sound(up,Fs); %
% pause(2); % EXECUTION EXAMPLE:
% %
% % [segments, fs] = detectVoiced('example.wav',1);
% y = up; %

%
function y = denoiseEm(x); %
% y = denoiseEm(x); % % Check if the given wav file exists:
% method to denoise a given signal using wavelets % fp = fopen(wavFileName, 'rb');
% x is the input Matlab sound file % if (fp<0)
% fprintf('The file %s has not been found!\n', wavFileName);
%THR is the threshold, SORH is for soft or hard thresholding, % return;
KEEPAPP allows you to keep % end
%approximation coefficients % fclose(fp);
[thr,sorh,keepapp]=ddencmp( 'den' , 'wv' ,x); %
% % Check if .wav extension exists:
% returns a de-noised version xc of input signal x (our one- % if (strcmpi(wavFileName(end-3:end),'.wav'))
dimensional speech signal) % % read the wav file name:
%obtained by wavelet coefficients thresholding using global % [x,fs] = wavread(wavFileName);
positive threshold THR % else
%PERF0 and PERFL2 are L2-norm recovery and compression % fprintf('Unknown file type!\n');
score in percentage. % return;
% end
 Flags1 = (E>=T_E);
% Convert mono to stereo Flags2 = (C>=T_C);
if (size(x, 2)==2) flags = Flags1 & Flags2;
x = mean(x')';
end if (nargin==3) % plot results:
clf;
% Window length and step (in seconds): subplot(3,1,1); plot(Eor, 'g'); hold on; plot(E, 'c');
win = 0.050; legend({'Short time energy (original)', 'Short time energy
step = 0.050; (filtered)'});
L = line([0 length(E)],[T_E T_E]); set(L,'Color',[0 0 0]);
%%%%%%%%%%%%%%%%%%%%%%%%%%% set(L, 'LineWidth', 2);
% THRESHOLD ESTIMATION axis([0 length(Eor) min(Eor) max(Eor)]);
%%%%%%%%%%%%%%%%%%%%%%%%%%%
subplot(3,1,2); plot(Cor, 'g'); hold on; plot(C, 'c');
Weight = 5; % used in the threshold estimation method legend({'Spectral Centroid (original)', 'Spectral Centroid
(filtered)'});
% Compute short-time energy and spectral centroid of the L = line([0 length(C)],[T_C T_C]); set(L,'Color',[0 0 0]);
signal: set(L, 'LineWidth', 2);
Eor = ShortTimeEnergy(x, win*fs, step*fs); axis([0 length(Cor) min(Cor) max(Cor)]);
Cor = SpectralCentroid(x, win*fs, step*fs, fs); end

% Apply median filtering in the feature sequences (twice),

using 5 windows: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% (i.e., 250 mseconds) % SPEECH SEGMENTS DETECTION
E = medfilt1(Eor, 5); E = medfilt1(E, 5); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C = medfilt1(Cor, 5); C = medfilt1(C, 5); count = 1;
WIN = 5;
% Get the average values of the smoothed feature sequences: Limits = [];
E_mean = mean(E); while (count < length(flags)) % while there are windows to be
Z_mean = mean(C); processed:
% initilize:
% Find energy threshold: curX = [];
[HistE, X_E] = hist(E, round(length(E) / 10)); % histogram countTemp = 1;
computation % while flags=1:
[MaximaE, countMaximaE] = findMaxima(HistE, 3); % find while ((flags(count)==1) && (count < length(flags)))
the local maxima of the histogram if (countTemp==1) % if this is the first of the current
if (size(MaximaE,2)>=2) % if at least two local maxima have speech segment:
been found in the histogram: Limit1 = round((count-WIN)*step*fs)+1; % set start
T_E = (Weight*X_E(MaximaE(1,1))+X_E(MaximaE(1,2))) limit:
/ (Weight+1); % ... then compute the threshold as the weighted if (Limit1<1) Limit1 = 1; end
average between the two first histogram's local maxima. end
else count = count + 1; % increase overall counter
T_E = E_mean / 2; countTemp = countTemp + 1; % increase counter of the
end CURRENT speech segment
end
% Find spectral centroid threshold:
[HistC, X_C] = hist(C, round(length(C) / 10)); if (countTemp>1) % if at least one segment has been found
[MaximaC, countMaximaC] = findMaxima(HistC, 3); in the current loop:
if (size(MaximaC,2)>=2) Limit2 = round((count+WIN)*step*fs); % set end
T_C = counter
(Weight*X_C(MaximaC(1,1))+X_C(MaximaC(1,2))) / if (Limit2>length(x))
(Weight+1); Limit2 = length(x);
else end
T_C = Z_mean / 2;
end Limits(end+1, 1) = Limit1;
Limits(end, 2) = Limit2;
% Thresholding: end
 count = count + 1; % increase overall counter for (j=1:length(segments))
end if (i~=j)
timeTemp = Limits(j,1)/fs:1/fs:Limits(j,2)/fs;
%%%%%%%%%%%%%%%%%%%%%%% P = plot(timeTemp, segments{j});
% POST - PROCESS % set(P, 'Color', [0.4 0.1 0.1]);
%%%%%%%%%%%%%%%%%%%%%%% end
end
% A. MERGE OVERLAPPING SEGMENTS: axis([0 time(end) min(x) max(x)]);
RUN = 1; end
while (RUN==1) end
RUN = 0;
for (i=1:size(Limits,1)-1) % for each segment
C. Anexo III
if (Limits(i,2)>=Limits(i+1,1))
RUN = 1;
Limits(i,2) = Limits(i+1,2); % GETMSWPFEAT Gets the Multiscale Wavelet Packet
Limits(i+1,:) = []; feature extraction.
break; % feat = getmswpfeatV00(x,winsize,wininc,SF,'toolbox')
end % ------------------------------------------------------------------
end % The signals in x are divided into multiple windows of size
end % "winsize" and the windows are spaced "wininc" apart.
% Inputs
% B. Get final segments: % ------
segments = {}; % x: columns of signals
for (i=1:size(Limits,1)) % winsize: number of samples per each window we extract
segments{end+1} = x(Limits(i,1):Limits(i,2)); features from
end % wininc: spacing of the windows, or simply the
increments between windows
if (nargin==3) % SF: sampling frequency
subplot(3,1,3); % toolbox 'matlab' if you plan to use the matlab wavelet
% Plot results and play segments: toolbox
time = 0:1/fs:(length(x)-1) / fs; % 'wmtsa' if you plan to use the wmtsa wavelet
for (i=1:length(segments)) toolbox
hold off; % ('http://www.atmos.washington.edu/wmtsa/')
P1 = plot(time, x); set(P1, 'Color', [0.7 0.7 0.7]); % Outputs
hold on; % -------
for (j=1:length(segments)) % feat: WPT features (compete tree without node
if (i~=j) selection)
timeTemp = Limits(j,1)/fs:1/fs:Limits(j,2)/fs;
P = plot(timeTemp, segments{j}); % Example
set(P, 'Color', [0.4 0.1 0.1]); % -------
end % Assume a random signal
end % x = rand(1024,1);
timeTemp = Limits(i,1)/fs:1/fs:Limits(i,2)/fs; % feat = getmswpfeatV00(x,256,32,256,'matlab')
P = plot(timeTemp, segments{i}); % Assuming here rand(1024,1) (this can be any one or multi
set(P, 'Color', [0.9 0.0 0.0]); dimensional signal,
axis([0 time(end) min(x) max(x)]); % for example EEG or EMG) is a one dimensional signal
sound(segments{i}, fs); sampled at 256
clc; % for 4 seconds only. Utilizing a window size of 256 at 32
fprintf('Playing segment %d of %d. Press any key to increments
continue...', i, length(segments)); % features are extracted from the wavelet packet tree.
pause % I assumed 7 decomposition levels (J=7) below in the code.
end % For a full tree at 7 levels you should get
clc % Level-0= 1 features
hold off; % Level-1= 2 features
P1 = plot(time, x); set(P1, 'Color', [0.7 0.7 0.7]); % Level-2= 4 features
hold on; % Level-3= 8 features
for (i=1:length(segments)) % Level-4= 16 features
% Level-5= 32 features
% Level-6= 64 features %% Start the process and loop along all dimensions (channels)
% Level-7= 128 features for i_Sig = 1:size(x,2)
% ---------------------
% Total = 255 features %% A sliding window approach with windows starting and
% and the result from the example above is feat is of size 25 x ending points
255 st = 1;
en = winsize;
% (Kindly cite either of the following papers if you use this
code) % Assuming that your input signal is continuous, chop it
% References: into segments of winsize length
% [1] R. N. Khushaba, A. Al-Jumaily, and A. Al-Ani, Novel for i = 1:numwin
Feature Extraction Method based on Fuzzy Entropy and Signals(1:winsize,i) = x(st:en,i_Sig);
Wavelet Packet Transform for Myoelectric Control, 7th st = st + wininc;
International Symposium on Communications and Information en = en + wininc;
Technologies ISCIT2007, Sydney, Australia, pp. 352 357. end
% [2] R. N. Khushaba, S. Kodagoa, S. Lal, and G.
Dissanayake, Driver Drowsiness Classification Using Fuzzy %% Decomposition levels
Wavelet Packet Based Feature Extraction Algorithm, IEEE % Number of decomposition levels is set as an input
Transaction on Biomedical Engineering, vol. 58, no. 1, pp. % It can also be set using
121-131, 2011. % J=wmaxlev(winsize,'Sym5');
% % or J=(log(SamplingFreq/2)/log(2))-1;
% Multiscale Wavelet Packet feature extraction code by Dr.
Rami Khushaba %% Perform multisignal wabelet packet
% Research Fellow - Faculty of Engineering and IT if strcmp(toolbox,'matlab')
% University of Technology, Sydney. D = mswpd('col',Signals,'db4',J); % WPT tree,
% Email: Rami.Khushaba@uts.edu.au the actual WP decomposition module using matlab toolbox
% URL: www.rami-khushaba.com (Matlab Code Section) else
% Last modified 19/06/2014 D = mswpd_wmtsa(Signals,'d4',J); % WPT
% first created 06/10/2011 tree, the actual WP decomposition module using wmtsa
%PS: original template for feature extraction inspired by the toolbox
work Dr. Adrian Chan % The following are possible wtf filter options rather
than 'd4'
function Features = getmswpfeat(x,winsize,wininc,J,toolbox) % @wtf_haar, ...
% @wtf_d4, ...
% Check the inputs % @wtf_d6, ...
if nargin <5 % @wtf_d8, ...
if nargin < 4 % @wtf_d10, ...
if nargin < 3 % @wtf_d12, ...
if nargin < 2 % @wtf_d14, ...
winsize = size(x,1); % @wtf_d16, ...
end % @wtf_d18, ...
wininc = winsize; % @wtf_d20, ...
end % @wtf_la8, ...
warning('Number of decomposition levels will be % @wtf_la10, ...
selected automatically') % @wtf_la12, ...
J = log(size(x,1))/log(2); % @wtf_la14, ...
end % @wtf_la16, ...
toolbox = 'matlab'; % @wtf_la18, ...
end % @wtf_la20, ...
% @wtf_bl14, ...
%% allocate memory % @wtf_bl18, ...
datasize = size(x,1); % @wtf_bl20, ...
numwin = floor((datasize - winsize)/wininc)+1; % @wtf_c6, ...
Signals = zeros(winsize,numwin); % @wtf_c12, ...
nfCh = (2^(J+1)-1); % number of features per channel % @wtf_c18, ...
Features = zeros(numwin,nfCh*size(x,2)); % @wtf_c24
end
 Temp = D{1,1}; % if op > 6 || op < 1
get first node content clc;
[nSmp] = size(Temp,2);clear Temp disp('Opo Invlida');
% number of signals pause(2);
feat = zeros(nSmp,2^(J+1)-1); else
% allocate memory for features clc;
[nL,nF] = size(D); % switch op
get size of WP tree case 1
index = 1; disp('Registrar amostra');
%for i=1:nL amostraVoz(input('Id da Classe?:'),true);
for i=nL:nL case 2
for j=1:nF disp('Registrar amostra de arquivo');
if ~isempty(D{i,j}) amostraArquivo(input('Id da Classe?:'),input('Nome
% This is where we extract the features (Log Root do Arquivo *.wav?:','s'),true,true);
Mean Square) case 3
feat(1:nSmp,index) = disp('Reconhecer locutor');
log(sqrt(mean(D{i,j}.*D{i,j})')); testarVoz();
index = index +1; disp('');
end input('Aperte Enter para continuar');
end case 4
end disp('Reconhecer locutor de um arquivo de som');
IndX = sum(feat,1); testarArquivo(input('Nome do Arquivo
IndX = (IndX~=0); *.wav?:','s'));
feat = feat(:,IndX); disp('');
nfCh = size(feat,2); input('Aperte Enter para continuar');
Features(:,((i_Sig-1)*(nfCh)+1):i_Sig*nfCh) = feat;
end case 5
%% Make sure you dont have all zero features [trainedClassifier, validationAccuracy]=
IndX = sum(Features); treinarClassificador();
IndX = (IndX~=0); disp(strcat('Acuracia do Classfificador:
Features = Features(:,IndX); ',num2str(validationAccuracy * 100),'%'));
disp('');
input('Aperte Enter para continuar');
D. Anexo IV
case 6
sair = true;
sair = false; end
try end
disp('carregando classificador...') end
load cassificador
catch
disp('O classificador ainda no foi treinado. Adicione um E. Anexo V
som para trein-lo.');
pause(2); function amostraVoz(id,tocar)
end try
while ~sair load database;
if(duracao<=0)
clc; error('durao invlida.');
disp('Sistema de Reconhecimento de Locutor'); end
disp(''); catch
disp(''); duracao = input('Durao da gravao: ');
disp('Escolha uma opo: '); end
disp('1. Registrar amostra ');
disp('2. Registrar amostra de arquivo '); Fs=6800; %frequencia de amostragem do sinal
disp('3. Reconhecer locutor '); record = audiorecorder(Fs,16,1,1); %criando o objeto de
disp('4. Reconhecer locutor de um arquivo de som '); gravador de udio a 44,1 kHz e 16 bits por amostra.
disp('5. Treinar/Estatisticas do Classificador'); disp('Comece a falar!');
disp('6. Sair '); recordblocking(record, duracao);
op = input('Opo:'); disp('Fim da gravao...');
y=getaudiodata(record); %Obtndo dados de udio gravados %Fs 2x 3400Hz
no objeto audiorecord com getaudiodata. %% aplica filtro passa faixas de 50Hz 3400Hz
if tocar %%obter 16 caracteristicas de energia no sinal em uma
sound(filtrar(y),Fs); determinada janela e
end %%insere em um vetor A
try
ids = [ids id]; %%para cada som no banco de dados aplica filtro passa faixas
sons = [sons y]; de 50Hz 3400Hz
save database ids sons duracao; %%obtem 16 caracteristicas de energia no sinal em uma
catch determinada janela
ids = id; %%relaciona o id da amostra e suas 16 caracteristicas em um
sons = y; vetor e o
save database ids sons duracao; %%adiciona em uma matriz;
end
treinarClassificador(); %%usando um cassificador
end %%para cada vetor da matriz, calcula a aproximao das
caracteristicas registradas e da atual entre as
%%caracteristicas do vetor A e as caracteristicas do vetor da
F. Anexo VI
matriz.

function amostraArquivo(id,arquivo,tocar,treinar)
[y,Fs] = audioread(arquivo);%Obtndo dados de udio %busca a menor distancia na matriz e retorna a classe
gravados no objeto audiorecord com getaudiodata. encontrada;
if(Fs> 6800) %//////////////////////////////////////////////////////////////////////////
newFs = 6800 ;
[P,Q] = rat(newFs/Fs); basesFaltantes = 0;
Fs = newFs;
y = y(:,1); feats = [];
y = resample(y,P,Q); y = amostraTeste();
end classe = reconhecerLocutor(y);
if tocar
sound(y,Fs); end
end
try
load databaseArquivo H. Anexo VIII
ids = [ids id];
sons = [sons y]; function classe = testarArquivo(arquivo)
save databaseArquivo ids sons; %%captura som de cada amostra e coloca no banco de dados
catch junto com o id da classe
ids = id; %Fs 2x 3400Hz
sons = y;
save databaseArquivo ids sons; %%Quando for tentar identificar uma pessoa:
end %%Obter uma amostra de udio
if treinar %Fs 2x 3400Hz
treinarClassificador(); %% aplica filtro passa faixas de 50Hz 3400Hz
end %%obter 16 caracteristicas de energia no sinal em uma
end determinada janela e
%%insere em um vetor A
G. Anexo VII
%%para cada som no banco de dados aplica filtro passa faixas
de 50Hz 3400Hz
function classe = testarVoz() %%obtem 16 caracteristicas de energia no sinal em uma
%%captura som de cada amostra e coloca no banco de dados determinada janela
junto com o id da classe %%relaciona o id da amostra e suas 16 caracteristicas em um
%Fs 2x 3400Hz vetor e o
%%adiciona em uma matriz;
%%Quando for tentar identificar uma pessoa:
%%Obter uma amostra de udio %%usando um cassificador
%%para cada vetor da matriz, calcula a aproximao das basesFaltantes = basesFaltantes+1;
caracteristicas registradas e da atual entre as end
%%caracteristicas do vetor A e as caracteristicas do vetor da try
matriz. load databaseArquivo
[l,c] = size(sons);
%busca a menor distancia na matriz e retorna a classe
encontrada; for i=1:c
%////////////////////////////////////////////////////////////////////////// som = sons(:,i);
continuar = true; somFeats = features(som);
try [lFeats,cFeats] = size(somFeats);
if(isempty(arquivo))
continuar = false; id_classe = repmat(ids(i),lFeats,1);
end classe = zeros(1,4);
catch classe(ids(i)) = 1;
continuar = false; classe = repmat(classe,lFeats,1);
end feats = [feats; [id_classe somFeats]];
if ~continuar featsRNAReady = [featsRNAReady; somFeats];
disp('O arquivo no pode ser vazio.'); classesRNAReady = [classesRNAReady; classe];
classe = -1; % figure;
return; % scatter(somFeats,yFeats);
end % lsline
[y,Fs] = audioread(arquivo); end
classe = reconhecerLocutor(y); catch
basesFaltantes = basesFaltantes+1;
end end
I. Anexo IX
if(basesFaltantes>1)
error('No possvel continuar. As bases de dados esto
function [trainedClassifier, validationAccuracy] = vazias.');
treinarClassificador() return;
end
basesFaltantes = 0; featsRNAReady = featsRNAReady';
classesRNAReady= classesRNAReady';
feats = []; save features feats featsRNAReady classesRNAReady ;
featsRNAReady = [];
classesRNAReady = []; disp('Treinando classificador...');
try [trainedClassifier, validationAccuracy] = trainClassifier(feats);
load database save cassificador trainedClassifier validationAccuracy
[l,c] = size(sons);
J. Anexo X
for i=1:c
som = sons(:,i); function [trainedClassifier, validationAccuracy] =
somFeats = features(som); trainClassifier(trainingData)
[lFeats,cFeats] = size(somFeats); % trainClassifier(trainingData)
% returns a trained classifier and its accuracy.
id_classe = repmat(ids(i),lFeats,1); % This code recreates the classification model trained in
classe = zeros(1,4); % Classification Learner app.
classe(ids(i)) = 1; %
classe = repmat(classe,lFeats,1); % Input:
feats = [feats; [id_classe somFeats]]; % trainingData: the training data of same data type as
featsRNAReady = [featsRNAReady; somFeats]; imported
classesRNAReady = [classesRNAReady; classe]; % in the app (table or matrix).
% figure; %
% scatter(somFeats,yFeats); % Output:
% lsline % trainedClassifier: a struct containing the trained
end classifier.
catch
% The struct contains various fields with information 'column_10', 'column_11', 'column_12', 'column_13',
about the 'column_14', 'column_15', 'column_16', 'column_17'};
% trained classifier. predictors = inputTable(:, predictorNames);
% response = inputTable.column_1;
% trainedClassifier.predictFcn: a function to make isCategoricalPredictor = [false, false, false, false, false, false,
predictions false, false, false, false, false, false, false, false, false, false];
% on new data. It takes an input of the same form as this
training % Train a classifier
% code (table or matrix) and returns predictions for the % This code specifies all the classifier options and trains the
response. classifier.
% If you supply a matrix, include only the predictors subspaceDimension = max(1, min(8, width(predictors) - 1));
columns (or classificationEnsemble = fitensemble(...
% rows). predictors, ...
% response, ...
% validationAccuracy: a double containing the accuracy in 'Subspace', ...
% percent. In the app, the History list displays this 30, ...
% overall accuracy score for each model. 'KNN', ...
% 'Type', 'Classification', ...
% Use the code to train the model with new data. 'NPredToSample', subspaceDimension, ...
% To retrain your classifier, call the function from the 'ClassNames', [1; 2; 3; 4]);
command line
% with your original data or new data as the input argument % Create the result struct with predict function
trainingData. predictorExtractionFcn = @(x) array2table(x,
% 'VariableNames', predictorNames);
% For example, to retrain a classifier trained with the original ensemblePredictFcn = @(x) predict(classificationEnsemble,
data set x);
% T, enter: trainedClassifier.predictFcn = @(x)
% [trainedClassifier, validationAccuracy] = ensemblePredictFcn(predictorExtractionFcn(x));
trainClassifier(T)
% % Add additional fields to the result struct
% To make predictions with the returned 'trainedClassifier' on trainedClassifier.ClassificationEnsemble =
new data T, classificationEnsemble;
% use trainedClassifier.About = 'This struct is a trained classifier
% yfit = trainedClassifier.predictFcn(T) exported from Classification Learner R2016a.';
% trainedClassifier.HowToPredict = sprintf('To make predictions
% To automate training the same classifier with new data, or on a new predictor column matrix, X, use: \n yfit =
to learn how c.predictFcn(X) \nreplacing ''c'' with the name of the variable
% to programmatically train classifiers, examine the that is this struct, e.g. ''trainedClassifier''. \n \nX must contain
generated code. exactly 16 columns because this classifier was trained using
16 predictors. \nX must contain only predictor columns in
% Auto-generated by MATLAB on 09-Jun-2017 19:18:35 exactly the same order and format as your training \ndata. Do
not include the response column or any columns you did not
import into \nClassification Learner. \n \nFor more
% Extract predictors and response information, see <a href="matlab:helpview(fullfile(docroot,
% This code processes the data into the right shape for training ''stats'', ''stats.map''),
the ''appclassification_exportmodeltoworkspace'')">How to
% classifier. predict using an exported model</a>.');
% Convert input to table
inputTable = array2table(trainingData, 'VariableNames', % Extract predictors and response
{'column_1', 'column_2', 'column_3', 'column_4', 'column_5', % This code processes the data into the right shape for training
'column_6', 'column_7', 'column_8', 'column_9', 'column_10', the
'column_11', 'column_12', 'column_13', 'column_14', % classifier.
'column_15', 'column_16', 'column_17'}); % Convert input to table
inputTable = array2table(trainingData, 'VariableNames',
predictorNames = {'column_2', 'column_3', 'column_4', {'column_1', 'column_2', 'column_3', 'column_4', 'column_5',
'column_5', 'column_6', 'column_7', 'column_8', 'column_9', 'column_6', 'column_7', 'column_8', 'column_9', 'column_10',
'column_11', 'column_12', 'column_13', 'column_14', an = a/max(a);
'column_15', 'column_16', 'column_17'});
%%pega a ocorrencia normalizada 1 e associa com a
predictorNames = {'column_2', 'column_3', 'column_4', posio no vetor de
'column_5', 'column_6', 'column_7', 'column_8', 'column_9', %%clases 'b'
'column_10', 'column_11', 'column_12', 'column_13', classe = -1;
'column_14', 'column_15', 'column_16', 'column_17'}; for i=1:length(an);
predictors = inputTable(:, predictorNames); if(an(i) == 1)
response = inputTable.column_1; classe = b(i);
isCategoricalPredictor = [false, false, false, false, false, false, break;
false, false, false, false, false, false, false, false, false, false]; end
end
% Perform cross-validation
partitionedModel = if ratio > R
crossval(trainedClassifier.ClassificationEnsemble, 'KFold', 5);
%%imprime a sada
% Compute validation accuracy saida = strcat('Classe Identificada: ', num2str(classe));
validationAccuracy = 1 - kfoldLoss(partitionedModel,
'LossFun', 'ClassifError'); else

% Compute validation predictions and scores

[validationPredictions, validationScores] = saida = strcat({'Classe no Identificada com confiana!
kfoldPredict(partitionedModel); Classe mais provvel: '}, num2str(classe));

classe= -1;
K. Anexo XI
end
rCarac = [b';a]
function [classe,ratio,rCarac] = reconhecerLocutor(y); disp(saida);
yFeats = features(y); saida = strcat({'Certeza em relao as caractersticas: '},
num2str(ratio* 100),'%');
try disp(saida);
isempty(trainedClassifier); saida = strcat({'Acurcia do Classificador: '},
catch num2str(validationAccuracy* 100),'%');
try disp(saida);
load cassificador
catch
disp('O classificador ainda no foi treinado. Adicione um
som para treina-lo.');
classe = -1;
ratio = 0.0000001;
return;
end
end
%%faz a predicao no classificador
yfit = trainedClassifier.predictFcn(yFeats);

%%conta as ocorrncia das classes nas predicoes

[a,b]=hist(yfit,unique(yfit));

%%verifica se a classe com maior quantidade de ocorrencias

tem no minimo
%% a razao minima 'R' de ocorrencias em funo da
quantidade de features;
R = 0.50;
maxA = max(a);
[lFeats, cFeats] = size(yFeats);
ratio = maxA/lFeats;
%%normaliza as ocorrencias no vetor de ocorrencias 'a'