Sistema Autônomo Localizador De Vazamentos: 11 korakov

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:04

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 á uma tubulação.

O postopku, ki je bil izveden, je algoritem nameščen na DRAGONBOARD 410c. Os dados também são enviados para um serviço na nuvem, odziv na pomožni 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), Participant do projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rod. Gomes Polo e Ronaldo P. Gomes Polo. Também deleou do projeto o aluno Daniel de Castro Pacheco graduando de engenharia mecânica na Universidade Newton Paiva de Belo Horizonte. O projekto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro e Felipe Crispim da Silva Salvagnini.

1. korak: Seznam materialov

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

1 Arduino Due

1 Dragonboard 410c

2 gonilnika za motor de corrente continua contendo cada um:

4 tranzistorji BC548

4 diode 1n4007

4 Zapori 4k7Ω ¼ W

1 Voznik za servo motorje:

1 Transistor BC548

1 dioda 1N4007

1 Upori 4k7Ω ¼ W

1 USB miška

1 Teclado USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispozitivo de cremalheira e engrenagem

1 servo motor 9 g

2. korak: Adaptação Mecânica

Para a aquisição dos dados pelo sensor piezoelétrico, faz se needá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 se trato de se tratar de pro trato de se tratar de pro trato de se tratar de pro trato de se tratar de pro trato de se trati tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme vídeo.

3. korak: Acionamento Dos Motores

Para executar a movimentação dos motores do robô ZUMO e do dispositivo de captura, fez-se neophodária a montagem de dois drivers para os motores de corrente continua e um driver for o servo motor, conforme as figuras acima, sendo a primeira figura o driver para um motor de corrente continua ea segunda ali driver za um servo motor.

4. korak: 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 podrobhes sobre o TCC dosos e sopod o tcos dospos eso pods oso tOSCos eso elektronski naslov [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.

Kot frekvence de interesse para ali projeto estão entre 100Hz e 800Hz. Para isso o dispositivo de sensoriamento foi configurado com uma frekvenência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, onde a Freência de aquisição deve estar pelo menos duas vezes acima das frekvence

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

5. korak: Konfigurirajte Do Arduino DUE (jezik C)

Devido a grande quantidade de dados, cerca de 3000 pontos por segundo, do tipo inteiro de 32 bits, gerados pelo dispositivo de sensoriamento e needsários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado or Arduino DUE para fazer uso de uma entrada Podatki o procesiranju, iso foi neophodário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine namestijo na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui poder de processamento para essa operação.

O Arduino DUE za konfiguracijo za sprejemnike, ki so namenjeni plataformi QUALCOMM DRAGONBOARD 410c, prek sporočila comunicação.

Kot konfiguracija brez Arduino foram:

Realizar a aquisição dos dados;

Oddajnik, ki je na voljo za DRAGONBOARD 410c;

Preverite program:

#include #define Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7

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

1); // 50% obratovalni cikel

TC_SetRC (tc, kanal, rc); TC_Start (tc, kanal); tc-> TC_CHANNEL [kanal]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // habilita os registradores tc-> TC_CHANNEL [kanal]. TC_IDR = ~ (TC_IER_CPCS | TC_IER_CPAS); // desabilita os registradores NVIC_EnableIRQ (irq); // habilita interrupção}

void setup ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Začetek časovnika // TC_Stop (TC1, 0); pinMode (SERVO, OUTPUT); }

void loop ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int indeks = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); stikalo (rc) {primer 1: indeks = 0; medtem ko (! Serial.available ()); medtem ko ((rc = Serial.read ())! = 0xFF) {indice << = 8; indeks += rc; medtem ko (! Serial.available ()); } Serial.print (0); Serijski.tisk (2); SendNumber (DAC [indeks]); Serijski.tisk (0xFF); zlom; primer 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; zamuda (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; zamuda (500); Serial.print (0); Serijski.tisk (4); Serijski.tisk (0xFF); } prelom; }} else if (rc == '2') {Serial.print ("Test Servo Motor / n"); medtem ko (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Način 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Način 2 / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; zamuda (100); SNow = PosServoMin; zamuda (100); }

6. korak: Interfaceamento Das Tecnologias

Če želite komunicirati z Arduíno DUE ea DRAGONBOARD 410c, uporabljajte vmesnik za figura acima, o tem, da ga lahko uporabite, izvedite opto-se, da uporabite USB vmesnik CDC za Arduino DUE ea DRAGONBOARD 4, needitaria da recompilação do KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

7. korak: Konfiguracija Da DRAGONBOARD 410c (Python)

Foi konfiguracija za enviar ao Arduino DUE os comandos para realizar a aquisição de dados e transmitir os dados obtidos. Segue código abaixo.

Opazovanje: 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. Če želite izbrati vmesnik USB za vmesnik, ki ga potrebujete, da ga ponovno sestavite na KERNEL na DRAGONBOARD 410c, namesto tega, da prenesete križnico, ki je primerna za komunikacijo.

import timeimport serijski uvoz pand kot pd uvoz numpy kot np

# Konfiguracija serijske serije

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

ser.isOpen ()

print ('Spodaj vnesite svoje ukaze. / r / nVnesite "exit", da zapustite aplikacijo.')

vnos = 1

medtem ko 1: input = input (">>") if 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

lista =

za i v dosegu (3000):

ser.write (i/256) ser.write ((i <0: out = ser.read (2) if (out == 0x0002): atual = 0 c = ser.read (1) while (c! = 0xFF): atual << 8 atual += cc = ser.read (1) lista.append (atual)

8. korak: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez neophodária a pogovorão dos arquivos no format WAV, fornecidos pelos alunos autores do TCC e colaboradores do projeto, para valores numéricos, que são utilizadoso 4 algoritam DROC. Za realizar esta pogovorão foi escrito um algoritmo em PYTHON 3 que lê o arquivo WAV e salva os dados do espectro em um arquivo CSV. O algoritmu utilizado segue abaixo e em anexo para download.

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

# kodiranje: utf-8

# Leitura e pogovorão dos audios para csv

# MÓDULOS UTILIZADOS

uvoz val uvoz numpy kot np uvoz pand kot pd uvoz matplotlib.pyplot kot plt

# FUNÇÃO PARA KONVERTER WAV EM DADOS DO ESPECTRO E SALVAR CSV

def avdio_to_csv (ime_datoteke): 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.readframe 1) 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 (signal), pd. DataFrame (čas)], os = 1) df.to_csv (ime_datoteke + '.csv', indeks = napačno) vrne df

# OKVIR PODATKOV CARREGANDO COM OS DADOS DO AUDIO

ime_datoteke = 'Solo_com_Vazamento' df_vazamento = avdio_to_csv (ime_datoteke) df_vazamento.columns = ['amp', 'čas'] ime_datoteke = 'Solo_sem_Vazamento' df_sem_vazamento = avdio_to_csv (ime_datoteke) [amp_sem_vans]

# GRÁFICO DO ESPECTRO DE AUDIO

slika, (ax1, ax2) = plt.subplots (nrows = 2, ncols = 1, figsize = (20, 10)) ax1.plot (df_vazamento ['time'], 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 ['time'], 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 ()

9. korak: Vizualno analizirajte

Com o PYTHON 3 je realiziral transformacijo de Fourierja, este artificio matemático realizacijo transformação do sinal do domínio do tempo para o domínio da freência, onde se torna possível analisar as variacies Frekvencias, e suas amplitude, que compõem aquele sinal. Pela análise visual do 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.

Omejite o eixo das frekvencah, ki vstopajo v 100Hz in 800Hz, fica claro v obstoječi vazamentos quando pa opazujte distúrbios nesse range de Freências.

# kodiranje: utf-8# Načini uporabe, ki se uporabljajo za preoblikovanje Fourierja

import pandas kot pd import numpy kot np import wave from matplotlib import pyplot as plt# Função que realization a transformata 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 ['time'] # Vetor de tempos y = y ['amp'] # Vetor de amplitude n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [obseg (n // 2)] Y = np.fft.fft (y)/n Y = Y [obseg (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 ('Time') 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 () return frq, abs (Y)# Function que realization a carga dos dados do CSV e chama and função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (file_name + '.csv') df.columns = ['amp', ' čas '] delta = final-init, če je init*44100> len (df) ali končno*44100> len (df): init = (len (df)/44100) -delta, če je init = 100) & (df [' freq '] <= 800)] mx = razvrščeno (df [' amp ']) print ("Amplitude Média das:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitude.") print ("100 maiores amplitude", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplitude:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplitud:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maior amplituda:", 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

10. korak: Algoritmo Em R Para Extração Das Lastnosti Dos Dados

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

Este primeiro algoritmo realiza uma extração identificada, onde é needário sabre 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 or treinamento da rede neural utilizada.

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

Estas features 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 programski opremi, uporabljeni za rodar ali o brezplačnem algoritmu, prenesite ali interpretirajte R e do R Studio.

Dodatne lastnosti:

• meanfreq: srednja frekvenca (v kHz)
• sd: standardni odklon frekvence
• mediana: srednja frekvenca (v kHz)
• Q25: prvi kvantil (v kHz)
• Q75: tretji kvantil (v kHz)
• IQR: interkvantilno območje (v kHz)
• poševno: poševno (glej opombo v opisu specifikacije)
• kurt: kurtosis (glej opombo v opisu specifikacije)
• sp.ent: spektralna entropija
• sfm: spektralna ravnost
• način: frekvenca načina
• centroid: frekvenčni centroid (glej specifikacijo)
• peakf: najvišja frekvenca (frekvenca z najvišjo energijo)
• meanfun: povprečje osnovne frekvence, merjeno po zvočnem signalu
• minfun: minimalna osnovna frekvenca, izmerjena v zvočnem signalu
• maxfun: največja osnovna frekvenca, merjena po zvočnem signalu
• meandom: povprečje prevladujoče frekvence, merjeno po zvočnem signalu
• mindom: minimalna prevladujoča frekvenca, merjena po zvočnem signalu
• maxdom: največja prevladujoča frekvenca, merjena po zvočnem signalu
• dfrange: območje prevladujoče frekvence, merjeno po zvočnem signalu
• modindx: indeks modulacije. Izračunano kot zbrana absolutna razlika med sosednjimi meritvami osnovnih frekvenc, deljena s frekvenčnim območjem
• oznaka: puščanje ali brez_puščanja

Algoritmo usado:

paketi <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'miši', 'e1071', 'rpart', 'xgboost', 'e1071') če (dolžina (setdiff (paketi, imena vrstic (installed.packages ())))> 0) {install.packages (setdiff (paketi, imena vrstic (installed.packages ())))}}

knjižnica (tuneR)

knjižnica (seewave) knjižnica (caTools) knjižnica (rpart) knjižnica (rpart.plot) knjižnica (randomForest) knjižnica (warbleR) knjižnica (miši) knjižnica (xgboost) knjižnica (e1071)

specan3 <- funkcija (X, bp = c (0, 22), wl = 2048, prag = 5, vzporedno = 1) { # Za uporabo vzporedne obdelave: knjižnica (devtools), install_github ('nathanvan/parallelsugar'), če (class (X) == "data.frame") {if (all (c ("sound.files", "selec", "start", "end") % v % colnames (X))) {start <- as.numeric (unlist (X $ start)) end <- as.numeric (unlist (X $ end)) sound.files <- as.character (unlist (X $ sound.files)) selec <- as.character (unlist (X $ selec))} else stop (paste (paste (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "start", "end") % v % colnames (X))], kolaps = ","), "stolpci v podatkovnem okviru niso najdeni"))} else stop ("X ni podatkovni okvir") #če so NA v začetni ali končni zaustavitvi, če (kakršna koli (is.na (c (konec, začetek))))) ustavitev ("NA najdena v začetku in/ali koncu") #če konec ali začetek nista numerična zaustavitev if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("" end "in" selec "morata biti številski") #če je kateri koli začetek višji od končne stop, če (poljuben (konec - začetek <0)) stop (prilepi ("Začetek je višji od en d in ", length (which (end - start20)) stop (paste (length (which (end - start> 20))," selection (s) long than 20 sec ")) options (show.error.messages = TRUE) #če bp ni vektor ali dolžina! = 2 stop, če (! is.vector (bp)) stop ("'bp' mora biti številski vektor dolžine 2") else {if (! length (bp) == 2) stop ("" bp "mora biti številski vektor dolžine 2")} #opozorilo o vrnitvi, če niso bile najdene vse zvočne datoteke fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (length (edinstveno (sound.files [(sound.files % v % fs)]))! = length (edinstveno (sound.files))) cat (paste (dolžina (edinstven (zvok datotek))-dolžina (edinstveno (sound.files [(sound.files % v % fs)]))), ".wav datotek ni najdenih")) #števanje zvočnih datotek v delovnem imeniku in če se 0 ustavi d <- kateri (sound.files % v % fs) if (length (d) == 0) {stop ("Datoteke.wav niso v delovnem imeniku")} else {start <- start [d] end <- konec [d] selek <- izbira [d] sound.files <- sound.files [d]} # Če vzporednik ni številski, če se (! is.numeric (vzporedno)) ustavi ("" vzporedno "mora biti številski vektor dolžine 1 ") if (kateri koli (! (vzporednik %% 1 == 0), vzporednik 1) {možnosti (opozori = -1) if (vse (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", tiho = TRUE) == TRUE)) lapp <- funkcija (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = vzporedna) else if (Sys.info () [1] == "Windows") {cat ("Uporabniki sistema Windows morajo namestiti paket" parallelsugar "za vzporedno računalništvo (tega zdaj ne počnete!)") Lapp <- pbapply:: pblapply} else lapp <- funkcija (X, FUN) vzporedno:: mclapply (X, FUN, mc.cores = vzporedno)} else lapp <- pbapply:: pblapply možnosti (opozori = 0) if (vzporedno == 1) cat ("Merjenje akustičnih parametrov:") x <- as.data.frame (lapp (1: length (start), function (i)) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), from = začetek , do = konec , enote = "sekunde") b strop ([email protected]/2000) - 1) b [2] < - strop ([email protected]/2000) - 1 #analiza frekvenčnega spektra songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analiza <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #parametri shranjevanja meanfreq <- analiza $ povprečje/1000 sd <- analiza $ sd/1000 mediana <- analiza $ mediana/1000 Q25 < - analiza $ QQ75 <- analiza $ QIQR <- analiza $ IQR/1000 skew <- analiza $ skewness kurt <- analiza $ kurtosis sp.ent <- analiza $ sh sfm <- analiza $ sfm način <- analiza $ način/1000 centroid <- analiza $ cent/1000 #Frekvenca z vrhovi amplitude peakf <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Temeljni frekvenčni parametri ff <- glej wavewave:: fund (r, f = [email protected], ovlp = 50, prag = prag, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] meanfun <-pomeni (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Prevladujoči parametri frekvence y <- glej wave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, prag = prag, pasovni pas = b * 1000, fftw = TRUE) [, 2] meandom <- povprečje (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) trajanje <- (konec - začetek ) #Izračun indeksa modulacije se spremeni <- vektor () za (j, v katerem (! je. na (y))) {sprememba <- abs (y [j]- y [j + 1]) spremembe <- dodaj (spremeni, spremeni)} če (mindom == maxdom) modindx <-0 else modindx <- povprečje (spremembe, na.rm = T)/dfrange #save rezultati vrnejo (c (trajanje, srednja frekvenca, sd, mediana, Q25, Q75, IQR, nagnjenost, kurt, sp.ent, sfm, način, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #spremenite imena rezultatov imen vrstic (x) <- c ("trajanje", "meanfreq", "sd", "mediana", "Q25", "Q75", "IQR", "poševno", "kurt", "sp.ent", "sfm", "način", "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") imena vrstic (x) <- c (1: nrow (x)) return (x)}

processFolder <- funkcija (ime mape) { # Začnite s praznim podatkovnim okvirjem. data <- data.frame () # Pridobite seznam datotek v mapi. list <- list.files (folderName, '\. wav') # Dodaj seznam datotek v podatkovni okvir za obdelavo. za (ime datoteke na seznamu) {vrstica <- data.frame (ime datoteke, 0, 0, 20) podatki <- rbind (podatki, vrstica)} # Nastavite imena stolpcev. names (data) <- c ('sound.files', 'selec', 'start', 'end') # Premakni se v mapo za obdelavo. setwd (ime mape) # Obdelajte datoteke. akustika <- specan3 (podatki, vzporednik = 1) # Premakni se nazaj v nadrejeno mapo. setwd ('..') akustika}

spol <- funkcija (datotekaPath) {če (! obstaja ('genderBoosted')) {load ('model.bin')} # Nastavitvene poti. currentPath <- getwd () fileName <- basename (filePath) pot <- dirname (filePath) # Nastavi imenik za branje datoteke. setwd (pot) # Začnite s praznim podatkovnim okvirjem. data <- data.frame (fileName, 0, 0, 20) # Nastavite imena stolpcev. names (data) <- c ('sound.files', 'selec', 'start', 'end') # Obdelava datotek. akustika <- specan3 (podatki, vzporednik = 1) # Obnovi pot. setwd (currentPath) napoved (genderCombo, newdata = akustika)}

# Naloži podatke

leakage <- processFolder ('caminho para o testenine com vzorcev de áudio com vazamento') without_leakage <- processFolder ('caminho para o testenine com vzorci de áudio sem vazamento')

# Nastavite oznake.

leakage $ label <- 1 without_leakage $ label <- 2 data <- rbind (leakage, without_leakage) data $ label <- faktor (podatki $ label, labels = c ('leakage', 'without_leakage'))

# Odstranite neuporabljene stolpce.

data $ duration <- NULL data $ sound.files <- NULL data $ selec <- NULL data $ peakf <- NULL

# Odstranite vrstice, ki vsebujejo NA.

podatki <- podatki [popolni. primeri (podatki),]

# Izpišite nabor podatkov csv.

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

11. korak: Odstranite nevralno

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

Rede nevralna uporaba é do tipo MLP (večplastni zaznavalec), este modelo é treinado com dados previamente identificados e após esse treinamento o modelo implantado no system conseguirá realizar a identificação automática do sinal recebido, informando se naqueo poonto exo

Foi needá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 površno 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. No 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.

# kodiranje: utf-8

uvoz pand kot pd

uvozi numpy kot np iz sklearn.model_selection uvoz train_test_split kot tts iz sklearn.neural_network uvozi MLPClassifier kot MLP iz sklearn.metrics uvoz classic_report kot cr iz sklearn.metrics uvoz confusion_matrix kot 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 kot entradas df_X = df_X

# Separando dados para treino e teste

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

# Criando modelo de rede nevral

modelo = MLP (alpha = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, activation = 'tanh', solver = 'lbfgs')

# Treinando modelo

modelo.fit (X_train, Y_train) rezultat = modelo.predict (X_test)

# Rezultati iskanja

poročilo = cr (Y_test, rezultat) mat = cm (y_pred = rezultat, y_true = Y_test) print ("Matriz de confusão") print (mat, end = "\ n / n") print ("Relatório de Classificação") tisk (poročilo)