Qhov System Autônomo Localizador De Vazamentos: 11 Kauj Ruam

2024 Tus sau: John Day | [email protected]. Kawg hloov kho: 2024-01-30 09:26

Este projeto consiste em um robô, que através da leitura realizada por um dispositivo, equipado com um sensor piezoelétrico, captura os espectros das vibrações no solo, pode identificar e localizar, com o processamento dos dados por uma rede neural, possíveis vazamentos de ág uma tubulaoo.

O processamento destes dados é realizado por algoritmos instalados na DRAGONBOARD 410c. Os dados também são enviados para um serviço na nuvem, responsável por auxiliar no processo de Integência Artificial do projeto.

Este projeto foi desenvolvido no Hackaton Qualcomm, durante a TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), koom tes ua projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas deousa, Gomes Polo thiab Ronaldo P. Gomes Polo. Também koom nrog ua cov phiaj xwm Daniel de Castro Pacheco kawm tiav qib siab ntawm engenharia mecânica na Universidade Newton Paiva de Belo Horizonte. O projeto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro e Felipe Crispim da Silva Salvagnini.

Kauj Ruam 1: Lista De Materiais

Para realização deste projeto, os seguintes materiais foram utilizados:

1 Arduino Daws

1 Dragonboard 410c

2 Tsav tsheb rau lub cev muaj zog de corrente txuas ntxiv txuas ntxiv cada um:

4 Transistores BC548

4 Diodos 1n4007

4 Resistores 4k7Ω ¼ W.

1 Tsav tsheb rau servo motor contendo:

1 Transistores BC548

1 Diodos 1N4007

1 Resistores 4k7Ω ¼ W.

1 Mus USB

1 Teclado USB

1 Saib

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini pov tseg pov tseg ntawm cremalheira e engrenagem

1 servo tsav 9g

Kauj Ruam 2: Hloov Kho Mecânica

Para aquisição dos dad pelo sensor piezoelétrico, faz se necessário, o desenvolvimento de um dispositivo com pinhão e cremalheira, conforme desenhos anexados, neste caso as peças foram fabricadas por uma impressora 3D, devido ao fato de serato de serato tempo de execução, fixou-se o dispositivo na plataforma zumo, siv tau zoo sib xws ob lub ntsej muag, ua raws li vídeo.

Kauj Ruam 3: Acionamento Dos Motores

Para executar a movimentação dos motores do robô ZUMO e do dispositivo de captura, fez-se necessária a montagem de dois drivers para os motores de corrente continua e um driver para o servo motor, conforme as figuras acima, sendo a primeira figura o driver para um lub cev muaj zog de corrente txuas ntxiv mus ea segunda o tsav tsheb rau um servo motor.

Kauj ruam 4: Obtenção Do Áudio

Para obtenção do espectro de áudio das vibrações do solo, foi utilizado um dispositivo desenvolvido como parte do TCC de Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro e Felipe C. da Silva Salvagnini, maiores detalhes sobre o detrés de sobre o detrare de sobre Ore de sitemas email [email protected].

Este dispositivo utiliza-se de um sensor piezoelétrico e uma placa de circuito que realiza a filtragem e amplificação do sinal.

Raws li cov kev xav tau tshwj xeeb rau kev ua haujlwm ntawm 100Hz thiab 800Hz. Para isso o dispositivo de sensoriamento foi configurado com uma frequência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, onde a frequência de aquisição deve estar pelo menos duas vezes acima das frequências estudad.

Aquisição é habilitada e desabilitada através da interrupção do Arduino DUE.

Kauj Ruam 5: Configuração Do Arduino DUE (linguagem C)

Devido a grande quantidade de dados, cerca de 3000 pontos por segundo, ua cov ntsiab lus inteiro de 32 khoom, gerados pelo dispositivo de sensoriamento e necessários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada com com poder de processamento, isso foi necessário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine instalado na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui poder de processamento para essa operação.

O Arduino DUE foi configurado para receber os comandos enviados da plataforma QUALCOMM DRAGONBOARD 410c ntawm comunicação cov ntawv.

Raws li kev teeb tsa tsis muaj Arduino foram:

Realizar a aquisição dos dados;

Transmitir os dados obtidos para a DRAGONBOARD 410c;

Qhia txog qhov program:

#suav nrog #txhais Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7 NPE

#define PosServoMin 4 #define PosServoMax 6 #define Period 60 unsigned int Scont = 0, SNow = PosServoMin; unsigned ntev int DAC [Numb_Sample], ind = Numb_Sample; void TC3_Handler () {TC_GetStatus (TC1, 0); yog (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); yog (Scont

1); // 50% kev ua haujlwm

TC_SetRC (tc, channel, rc); TC_Start (tc, channel); tc-> TC_CHANNEL [channel]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // habilita os registerradores tc-> TC_CHANNEL [channel]. TC_IDR = ~ (TC_IER_CPCS | TC_IER_CPAS); // desabilita os tus neeg sau npe NVIC_EnableIRQ (irq); // txoj kev sib hlub}

void teeb tsa ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Init Timer // TC_Stop (TC1, 0); tus pinMode (SERVO, OUTPUT); }

void lub voj ()

{/*// thaum (! Serial.available ()); char rc; // = Serial.read (); cov indice = 0; yog (rc == 0) {thaum (! Serial.available ()); rc = Serial.read (); hloov (rc) {rooj plaub 1: indice = 0; thaum (! Serial.available ()); thaum ((rc = Serial.read ())! = 0xFF) {indice << = 8; indice += rc; thaum (! Serial.available ()); } Serial.print (0); Serial.print (2); SendNumber (DAC [cim]); Serial.print (0xFF); tawg; rooj plaub 3: thaum (! Serial.available ()); yog ((Serial.read ()) == 0xFF) {SNow = PosServoMax; ncua (500); cov = 0; // TC_Start (TC1, 0); thaum (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; ncua (500); Serial.print (0); Serial.print (4); Serial.print (0xFF); } tawg; }} lwm qhov yog (rc == '2') {Serial.print ("Test Servo Motor / n"); thaum (! Serial.available ()); rc = Serial.read (); yog (rc == '1') {Serial.print ("Hom 1 / n"); SNow = PosServoMax; } yog (rc == '2') {Serial.print ("Hom 2 / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; ncua (100); SNow = PosServoMin; ncua (100); }

Kauj Ruam 6: Interfaceamento Das Tecnologias

Para a comunicação dos dados entre o Arduíno DUE ea DRAGONBOARD 410c, inicialmente utilizou-se a interface da figura acima, o que não foi possível executar, então optou-se pelo uso de uma interface USB CDC entre o Arduino DUE ea DRAGONBOARD 410c, necessitaria da recompilação ua KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

Kauj Ruam 7: Configuração Da DRAGONBOARD 410c (Python)

Foi configurada para enviar ao Arduino DUE os comandos para realizar a aquisição de dados e transmitir os dados obtidos. Ua raws li cov lus pom zoo.

Soj ntsuam: A abordagem utilizada no código, não funcionou devido aos níveis de tensão utilizados pelo Arduíno DUE e o Mezzanine serem incompatíveis. Por isso optou-se pelo interfaceamento USB, que necessitaria da recompilação do KERNEL na DRAGONBOARD 410c para que a porta fosse criada corretamente para a comunicação.

ntshuam lub sij hawm ntshuam ntshuam pandas raws li pd import numpy li np

# Configuração thiab conexão serial

ser = serial. Serial (chaw nres nkoj = '/dev/ttyAMC0', #tty96B0 ', baudrate = 250000, parity = serial. PARITY_NONE, stopbits = serial. STOPBITS_ONE, bytesize = serial. EIGHTBITS)

ser.isOpen ()

print ('Sau koj cov lus txib hauv qab no. / r / nSert "exit" kom tawm hauv daim ntawv thov.')

cov tswv yim = 1

thaum 1: input = input (">>") yog input == 'exit': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comando para o Arduino DUE realizar a coleta dos dados ser.write (1) # Envia o comando para o Arduino DUE transmitir os dados coletados

lis =

rau kuv hauv ntau (3000):

ser.write (i/256) ser.write ((kuv <0: tawm = ser.read (2) yog (tawm == 0x0002): atual = 0 c = ser.read (1) thaum (c! = 0xFF): atual << 8 atual += cc = ser.read (1) lista.append (atual)

Kauj Ruam 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dad obtidos através do sensor, se fez necessária a conversão dos dos arquivos no formato WAV, fornecidos pelos alunos autores do TCC e colaboradores do projeto, para valores numéricos, que são utilizados nos algoritmos 10. Para realizar esta conversão foi escrito um algoritmo em PYTHON 3 que lê o arquivo WAV e salva os dados do espectro em um arquivo CSV. Nws yog qhov ua tau los ntawm kev ua raws li cov lus pom zoo rau rub tawm.

Esse algoritmo não se faz necessário para o funcionamento do sistema, já que o Arduino DUE já enviará esses dados em um array de valores numéricos.

# coding: ua-8

# Leitura e Conversão dos dos audios para csv

# MÓDULOS UTILIZADOS

ntshuam ntshuam ntshuam numpy li np import pandas li pd ntshuam matplotlib.pyplot li plt

# FUNÇÃO PARA CONVERTER WAV EM DADOS Ua ESPECTRO E SALVAR CSV

def audio_to_csv (file_name): wave_file = wave.open (file_name+'. wav', 'rb') data_size = wave_file.getnframes () sample_rate = wave_file.getframerate () time_step = 1/sample_rate waveData = wave_file.readframes (data_size)) signal = np.fromstring (waveData, dtype = 'int32') Time = np.linspace (start = 0, stop = data_size/sample_rate, num = data_size, endpoint = True) df = pd.concat ([pd. DataFrame (teeb liab), pd. DataFrame (Lub Sijhawm)], axis = 1) df.to_csv (file_name + '.csv', index = False) rov qab df

# CARREGANDO DATA FRAME COM OS DADOS Ua AUDIO

file_name = 'Solo_com_Vazamento' df_vazamento = audio_to_csv (file_name) df_vazamento.columns = ['amp', 'time'] file_name = 'Solo_sem_Vazamento' df_sem_vazamento = audio_to_csv (file_name) df_sem

# GRÁFICO Ua ESPECTRO DE AUDIO

figure, (ax1, ax2) = plt.subplots (nrows = 2, ncols = 1, figsize = (20, 10)) ax1.plot (df_vazamento ['sijhawm'], df_vazamento ['amp']) ax1.set_title ('Solo com Vazamento', fontdict = {'fontsize': 20, 'fontweight': 'bold'}) ax1.set_xlabel ('Tempo [s]', fontdict = {'fontsize': 16}) ax1.set_ylim ([-4e8, 4e8]) ax2.plot (df_sem_vazamento ['sijhawm'], df_sem_vazamento ['amp']) ax2.set_title ('Solo sem Vazamento', fontdict = {'fontsize': 20, 'fontweight': 'bold' }) ax2.set_xlabel ('Tempo [s]', fontdict = {'fontsize': 16}) ax2.set_ylim ([-4e8, 4e8]) figure.tight_layout (h_pad = 5) plt.show ()

Kauj Ruam 9: Ua Kom Pom Kev Pom Zoo Ua Sinal

Com o PYTHON 3 é realizada a transformada de Fourier, este artificio matemático realiza a transformação do sinal do domínio do tempo para o domínio da frequência, onde se torna possível analisar as varias frequências, e suas amplitudes, que compõem aquele sinal. Pela análise nrig txog kev pom gráfico da transformada de Fourier um profissional com conhecimentos específicos poderá identificar a existência de algum vazamento na tubulação. Estes gráficos servirão para validação das análises realizadas pelo algoritmo de detecção automática.

Limitando o eixo das frequências entre 100Hz e 800Hz, fica claro a existência de vazamentos quando se observam distúrbios nesse range de frequências.

# coding: utf-8# Módulos utilizados para processamento da transformada de Fourier

import pandas as pd import numpy as np import wave from matplotlib import pyplot as plt# Função que realiza a transformada de Fourier e plota os gráficos para análise def Fourier (df_list): Fs = 44100; # Taxa de amostragem em Hz Ts = 1.0/Fs; # Intervalo de amostragem y = pd.concat (df_list) t = y ['sijhawm'] # Vetor de tempos y = y ['amp'] # Vetor de amplitudes n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [range (n // 2)] Y = np.fft.fft (y)/n Y = Y [range (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) fig, ax = plt.subplots (2, 1, figsize = (20, 10)) ax [0].plot (t, y) ax [0].set_xlabel ('Sijhawm') ax [0].set_ylabel ('Amplitude') ax [1].plot (frq, abs (Y), 'r') ax [1].set_xlim ([100, 800]) ax [1].set_ylim ([0, max_lim]) ax [1].set_xlabel ('Freq (Hz)') ax [1].set_ylabel ('| Y (freq) |') plt.show () rov qab frq, abs (Y)# Função que realiza a carga dos dados do CSV e chama a função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (file_name + '.csv') df.columns = ['amp', ' sij hawm '] delta = zaum kawg-pib yog init*44100> len (df) lossis zaum kawg*44100> len (df): init = (len (df)/44100) -delta yog init = 100) & (df [' freq '] <= 800)] mx = sorted (df [' amp ']) print ("Média das amplitudes:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") print ("100 maiores amplitudes", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplitudes:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplitudes:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maior amplitude:", np.mean (mx [-1:]) // df ['amp']. mean ()*100, " %", sep =" ") read_csv ('Solo_com_Vazamento', 2, 10) # Exemplo de gráficos para vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Exemplo de gráficos para sem vazamento

Kauj Ruam 10: Algoritmo Em R Para Extração Das Nta Dos Dados

Utilizou-se um algoritmo em R para realizar o processamento e extração das nta (características) dos dados obtidos.

Este primeiro algoritmo realiza uma extração identificada, onde é necessário saber se o arquivo de áudio trata-se de uma amostra vazamento detectado ou não, isso por que os dados resultantes desse processo servirão para o treinamento da rede neural utilizada.

Para quando o sistema estiver em modo de operação um algoritmo um pouco diferente será executado, onde não este fará a extração não identificada, gerando somente as características sem uma identificação.

Estas nta ou caraterísticas são propriedades acústicas compostas por varias informações referentes ao espectro de áudio capturado, abaixo seguirá uma descrição (em inglês) destas características.

Este algoritmo faz parte de um projeto disponível no GitHub e pode ser acessado através deste link, o mesmo foi modificado para atender as especificações do projeto.

O software siv rau kev siv lossis ua raws li qhov ua tau zoo, rub tawm tus txhais lus R thiab ua R Studio.

Cov yam ntxwv tshwj xeeb:

• meanfreq: nruab nrab zaus (hauv kHz)
• sd: txheem sib txawv ntawm zaus
• nruab nrab: nruab nrab zaus (hauv kHz)
• Q25: thawj quantile (hauv kHz)
• Q75: thib peb quantile (hauv kHz)
• IQR: ntau yam sib txawv (hauv kHz)
• skew: skewness (saib ceeb toom hauv cov lus piav qhia tshwj xeeb)
• kurt: kurtosis (saib ceeb toom hauv cov lus piav qhia tshwj xeeb)
• sp.ent: spectral entropy
• sfm: spectral flatness
• hom: hom zaus
• centroid: zaus centroid (saib specprop)
• peakf: ncov zaus (zaus nrog lub zog siab tshaj)
• meanfun: nruab nrab ntawm qhov tseem ceeb ntsuas ntsuas hla lub teeb liab suab
• minfun: yam tsawg kawg nkaus yuav tsum tau ntsuas hla lub teeb liab suab
• maxfun: qhov siab tshaj plaws yuav tsum tau ntsuas hla lub teeb liab suab
• meandom: qhov nruab nrab ntawm qhov tseem ceeb ntsuas ntsuas hla lub teeb liab suab
• mindom: yam tsawg kawg ntawm qhov tseem ceeb ntsuas ntsuas hla lub teeb liab suab
• maxdom: qhov siab tshaj plaws ntawm qhov ntsuas tau ntsuas hla lub teeb liab suab
• dfrange: qhov ntau ntawm cov zaus tseem ceeb ntsuas hla lub teeb liab suab
• modindx: ntsuas qhov ntsuas. Xam raws li qhov sib txawv ntawm qhov ntsuas ib puag ncig ntawm cov hauv paus zaus sib faib los ntawm ntau zaus
• daim ntawv lo: to los yog tsis muaj_leakage

Algoritmo siv:

pob <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'nas', 'e1071', 'rpart', 'xgboost', 'e1071') yog (ntev (setdiff (pob khoom, rownames (install.packages ())))> 0) {install.packages (setdiff (pob, rownames (install.packages ()))))

qiv (tuneR)

library (seewave) library (caTools) library (rpart) library (rpart.plot) library (randomForest) library (warbleR) library (nas) library (xgboost) library (e1071)

specan3 <- muaj nuj nqi (X, bp = c (0, 22), wl = 2048, pib = 5, thaum uas tig mus = 1) { # Txhawm rau siv kev ua haujlwm sib xws: tsev qiv ntawv (devtools), install_github ('nathanvan/parallelsugar') yog (chav kawm (X) == "data.frame") {yog (tag nrho (c ("sound.files", "selec", "start", "end") % hauv % colnames (X))) {pib <- as.numeric (unlist (X $ pib)) kawg <- as.numeric (tsis sau (X $ kawg)) sound.files <- as.character (tsis teev (X $ sound.files)) selec <- as.character (unlist (X $ selec))} lwm qhov nres (muab tshuaj (paste (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "pib", "xaus") % hauv % colnames (X))], sib tsoo = ","), "kem (s) tsis pom hauv cov ntaub ntawv"))} lwm qhov nres ("X tsis yog cov ntaub ntawv thav duab") #yog tias muaj NAs pib lossis xaus yog tias (ib qho (is.na (c (kawg, pib))))) nres ("NAs pom hauv kev pib thiab/lossis xaus") #if kawg lossis pib tsis yog tus lej nres yog (tag nrho (chav kawm (kawg)! = "tus lej" & chav kawm (pib)! = "tus lej"))) nres ("'kawg' thiab 'selec' yuav tsum yog tus lej") #yog tias muaj qhov pib siab dua qhov kawg nres yog (ib qho (qhov kawg - pib <0)) nres (muab tshuaj ("Pib yog siab dua li en d hauv ", ntev (uas (kawg - pib 20)) nres (muab tshuaj (ntev (uas (kawg - pib> 20))," xaiv (s) ntev dua 20 sec ")) xaiv (show.error.messages = TRUE) #if bp tsis yog vector lossis ntev! = 2 nres yog (! is.vector (bp)) nres ("'bp' yuav tsum yog tus lej lej ntawm qhov ntev 2") lwm {yog (! ntev (bp) == 2) nres ("'bp' yuav tsum yog tus lej vector ntawm qhov ntev 2")} #rov ceeb toom yog tias tsis yog txhua cov ntaub ntawv suab tau pom fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) yog (ntev (tshwj xeeb (suab.files [(suab.files % hauv % fs)]))! = ntev (tshwj xeeb (suab.files))) miv (muab tshuaj (ntev (tshwj xeeb (suab). cov ntaub ntawv))-ntev (tshwj xeeb (sound.files [(sound.files % hauv % fs)])), ".wav cov ntawv (tsis pom)")) #count tooj ntawm cov suab ntaub ntawv hauv cov npe ua haujlwm thiab yog 0 nres d <- uas (sound.files % hauv % fs) yog (ntev (d) == 0) {nres ("Cov.wav cov ntaub ntawv tsis nyob hauv cov npe ua haujlwm")} lwm qhov {pib <- pib [d] kawg <- kawg [d] selec <- selec [d] sound.files <- sound.files [d]} # Yog hais tias thaum uas tig mus tsis suav tus lej yog (! is.numeric (parallel)) nres ("'parallel' yuav tsum ua tus lej lej ntawm qhov ntev 1 ") yog (ib qho (! (parallel %% 1 == 0), parallel 1) {xaiv (ceeb toom = -1) yog (tag nrho (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", ntsiag to = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) lwm yam yog (Sys.info () [1] == "Windows") {miv ("Windows cov neeg siv yuav tsum tau teeb tsa pob 'parallelsugar' rau kev suav ua ke (koj tsis ua tam sim no!)") Lapp <- pbapply:: pblapply} lwm qhov lapp <- muaj nuj nqi (X, FUN) parallel:: mclapply (X, FUN, mc.cores = parallel)} lwm qhov lapp <- pbapply:: pblapply xaiv (ceeb toom = 0) yog (parallel == 1) miv ("Ntsuas cov suab tsis:") x <- as.data.frame (lapp (1: ntev (pib), muaj nuj nqi (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), los ntawm = pib , mus = kawg , units = "seconds") b qab nthab ([email protected]/2000) - 1) b [2] < - qab nthab ([email protected]/2000) - 1 #frequency spectrum analysis songspec <- seewave:: spec (r, f = [email protected], phiaj = FALSE) tsom xam <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), phiaj = FALSE) #save tsis meanfreq <- tsom xam $ txhais/1000 sd <- tsom xam $ sd/1000 nruab nrab <- tsom xam $ nruab nrab/1000 Q25 < - tsom xam $ QQ75 <- tsom xam $ QIQR <- tsom xam $ IQR/1000 skew <- tsom xam $ skewness kurt <- tsom xam $ kurtosis sp.ent <- tsom xam $ sh sfm <- tsom xam $ sfm hom <- tsom xam $ hom/1000 centroid <- tsom xam $ cent/1000 #Frequency nrog amplitude peaks peakf <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, phiaj = FALSE) [1, 1] #Fundamental zaus tsis ff <- seewave:: fund (r, f = [email protected], ovlp = 50, threshold = threshold, fmax = 280, ylim = c (0, 280/1000), phiaj = FALSE, wl = wl) [, 2] meanfun <-mean (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Dominant frecuency tsis y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, phiaj = F, pib = pib, bandpass = b * 1000, fftw = TRUE) [, 2] meandom <- mean (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) ntev <- (kawg - pib ) #kev ntsuas ntsuas ntsuas kev hloov <- vector () rau (j uas (! yog. na (y))) {hloov <- abs (y [j]- y [j + 1]) hloov <- txuas ntxiv (hloov pauv, hloov)} yog (mindom == maxdom) modindx <-0 lwm tus modindx <- txhais (hloov pauv, na.rm = T)/dfrange #khaws cov txiaj ntsig tau rov qab (c (ntev, meanfreq, sd, nruab nrab, Q25, Q75, IQR, skew, kurt, sp.ent, sfm, hom, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))))) #hloov pauv cov npe rownames (x) <- c ("ntev", "meanfreq", "sd", "nruab nrab", "Q25", "Q75", "IQR", "skew", "kurt", "sp.ent", "sfm", "mode", "centroid", "peakf", "meanfun", "minfun", "maxfun", "meandom", "mindom", "maxdom", "dfrange", "modindx") x <- data.frame (sound.files, selec, as.data.frame (t (x))) colnames (x) [1: 2] <- c ("sound.files", "selec") rownames (x) <- c (1: nrow (x)) return (x)}

processFolder <- muaj nuj nqi (folderName) { # Pib nrog khoob data.frame. cov ntaub ntawv <- data.frame () # Tau txais cov npe ntawm cov ntaub ntawv hauv daim nplaub tshev. list <- list.files (folderName, '\. wav') # Ntxiv daim ntawv teev npe rau data.frame rau kev ua. rau (fileName hauv daim ntawv teev npe) {kab <- data.frame (fileName, 0, 0, 20) cov ntaub ntawv <- rbind (cov ntaub ntawv, kab)} # Teeb cov npe kab. cov npe (cov ntaub ntawv) <- c ('sound.files', 'selec', 'start', 'end') # Txav mus rau hauv daim nplaub tshev rau kev ua. setwd (folderName) # Txheej txheem cov ntaub ntawv. acoustics <- specan3 (cov ntaub ntawv, thaum uas tig mus = 1) # Rov qab mus rau hauv niam ntawv. setwd ('..') acoustics}

poj niam txiv neej <- muaj nuj nqi (filePath) {yog (! muaj nyob ('genderBoosted')) {load ('model.bin')} # Teeb txoj hauv kev. currentPath <- getwd () fileName <- basename (filePath) txoj kev <- dirname (filePath) # Teeb cov npe rau nyeem cov ntawv. setwd (txoj kev) # Pib nrog cov ntaub ntawv khoob. data <- data.frame (fileName, 0, 0, 20) # Teeb cov npe kab. names (data) <- c ('sound.files', 'selec', 'start', 'end') # Txheej txheem cov ntaub ntawv. acoustics <- specan3 (cov ntaub ntawv, thaum uas tig mus = 1) # Kho txoj hauv kev. setwd (currentPath) kwv yees (genderCombo, newdata = acoustics)}

# Thauj cov ntaub ntawv

to < / processFolder ('caminho para o pasta com samples de áudio com vazamento') without_leakage <- processFolder ('caminho para o pasta com samples de áudio sem vazamento')

# Teeb cov ntawv cim.

to $ daim ntawv lo <- 1 tsis muaj_leakage $ daim ntawv lo <- 2 cov ntaub ntawv <- rbind (xau, tsis_leakage) cov ntaub ntawv $ daim ntawv lo <- yam (cov ntaub ntawv $ daim ntawv lo, ntawv cim = c ('to', 'tsis muaj_leakage'))

# Tshem tawm kab uas tsis siv.

cov ntaub ntawv $ ntev <- NULL cov ntaub ntawv $ sound.files <- NULL cov ntaub ntawv $ selec <- NULL cov ntaub ntawv $ peakf <- NULL

# Tshem tawm kab uas muaj NA's.

cov ntaub ntawv <- cov ntaub ntawv [ua tiav.cases (cov ntaub ntawv),]

# Sau tawm cov ntaub ntawv csv.

write.csv (data, file = 'features.csv', sep = ',', row.names = F)

Kauj Ruam 11: Rede Neural

A ideia do uso de uma rede neural, é a de realizar um reconhecimento automatizado através dos dados coletados pelo dispositivo de sensoriamento.

Rede neural utilizada é do tipo MLP (Multilayer Perceptron), este modelo é treinado com dados prequipee identificados e após esse treinamento o modelo implantado no sistema conseguirá realizar a identificação automática do sinal recebido, informando se naquele pont existo.

Foi necessário realizar uma filtragem dos dados de entrada, pois algumas características estavam diminuindo a taxa de acerto da rede ao invés de melhora-la. Não foi realizado nenhuma abordagem estatística muito aprofundada, mas mesmo com um trabalho mais superficial pode-se chegar a algumas variáveis com bons desempenhos.

Para os testes realizados o modelo obteve um desempenho muito bom, alcançando na maioria dos testes uma taxa de acerto de 100%, como pode ser observado na imagem anexa.

Este algoritmo é utilizado para treinar o modelo da rede e retornar a taxa de acerto do mesmo. Tsis muaj qhov system de detecção um algoritmo um pouco diferente seria usado, pois ele realizaria o treino ou receberia um modelo já treinado da nuvem ou de alguma outra fonte e com esse modelo realizaria as predições para cada leitura realizada.

# coding: ua-8

ntshuam pandas li pd

ntshuam numpy li np los ntawm sklearn.model_selection ntshuam train_test_split li tts los ntawm sklearn.neural_network import MLPClassifier li MLP los ntawm sklearn.metrics ntshuam classification_report li cr los ntawm sklearn.metrics ntshuam tsis meej_matrix li cm

# Leitura dos dados do CSV

df = pd.read_csv ('features.csv') # Separação das entradas df_X = df [df.columns [: len (df.columns) -1] # Filtrando as entradas df_X = df_X

# Txheeb xyuas qhov ua tau zoo ntawm cov ntawv xeem

X_train, X_test, Y_train, Y_test = tts (df_X, df_Y, test_size = 0.1)

# Criando qauv de rede neural

modelo = MLP (alpha = 0.0001, learning_rate_init = 0.0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, ua kom = 'tanh', daws = 'lbfgs')

# Tsim qauv

modelo.fit (X_train, Y_train) tshwm sim = modelo.predict (X_test)

# Imprimindo qhov tshwm sim

report = cr (Y_test, result) mat = cm (y_pred = result, y_true = Y_test) print ("Matriz de confusão") print (mat, end = "\ n / n") print ("Relatório de Classificação") print (qhia)