Sistema Autònom Localitzador De Vazamentos: 11 Steps

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:12

Aquest projecte consisteix en un robó, que es converteix en una lectura realitzada per un dispositiu, equipat amb un sensor piezoelèctric, capta els espectres de les vibracions no només, es pot identificar i localitzar, com o processament dos dies per uma rede neural, possibles vazamentos de água em uma tubulação.

O processament d'aquests dies és realitzat per algoritmes instal·lats a DRAGONBOARD 410c. Os dados també são enviados para um serviço na nuvem, responsável per auxiliar no process de Integência Artificial do projecto.

Aquest projecte es va desenvolupar no Hackaton Qualcomm, durant a TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), participaram do projecto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigues, Rogério Ap. Gomes Polo i Ronaldo P. Gomes Polo. Também participou do projecto o aluno Daniel de Castro Pacheco graduando de engenharia mecânica na Universidade Newton Paiva de Belo Horizonte. O projecto contou com o suport dos graduats d’engenharia mecatrônica da FACENS, Lucas Nunes Monteiro e Felipe Crispim da Silva Salvagnini.

Pas 1: Llista de materials

Per a la realització d’aquest projecte, els següents materials relacionats amb els usos següents:

1 Arduino Due

1 Dragonboard 410c

2 Drivers per motor de corrent contínua continuant cada any:

4 transistors BC548

4 Diodos 1n4007

4 resistències 4k7Ω ¼ W

1 controlador per a servomotor que conté:

1 Transistores BC548

1 Diodos 1N4007

1 Resistors 4k7Ω ¼ W

1 ratolí USB

1 teclat USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositiu de cremalheira i engrenagem

1 Servomotor de 9 g

Pas 2: adaptació mecànica

Para a aquisição dos dados pelo sensor piezoelétrico, faz se necessário, o development of um device com pinhão e cremalheira, conforme desenhos anexados, neste cas as peças foram fabricades per uma impressora 3D, devido ao fato de se tratar de um protótipo e ao curto tempo de execução, fixou-se o dispositivo na plataforma zumo, utilitzant fita dupla face, conforme vídeo.

Pas 3: Acionament Dos Motors

Per executar una movimentació dos motors do robô ZUMO e do device de captura, fez-se necessaria a montagem de dois drivers per a motors de corrent continu i um driver for o servo motor, conforme as figuras acima, sendo a primera figura o driver para um motor de corrente continua ea segunda o driver para um servo motor.

Pas 4: Obtenir Do Áudio

Per obtenirção do espectro de áudio das vibrações do solo, foi utilitzat amb dispositiu desenvolupat com a part do TCC de Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro e Felipe C. da Silva Salvagnini, maiores detalhes sobre o TCC e sobre o dispositiu podem ser sol·licitats através do envieu un correu electrònic a [email protected].

Aquest dispositiu utilitza-se de un sensor piezoelèctric i una placa de circuit que realitza un filtratge i amplificació de sinal.

Com a freqüències d’interès per a un projecte de 100Hz i 800Hz. Para isso o dispositivo de sensoriamento foi configurado com uma frequência de amostragem de 3 kHz para que sejam respeitada as conditionsções do teorema de amostragem de Nyquist, onde a frequência de aquisição deve estar pelo menos duas veces acima das frequências estudadas.

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

Pas 5: Configuració de l'Arduino DUE (linguagem 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 necesarios para procesamiento dos algoritmos na DRAGONBOARD 410c, va ser utilitzat o Arduino DUE per a fer-ne més un ús d’entrada analògica com major poder de processament, isso foi necessário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine instalado na DRAGONBOARD 410c, que posseeix un microcontrolador ATmega 328, no té poder de processament per a aquesta operació.

O Arduino DUE ha estat configurat per rebre comandaments enviats per la plataforma QUALCOMM DRAGONBOARD 410c mitjançant la comunicació de sèrie.

Com a configuracions no configurades en Arduino:

Realizar a aquisição dos dados;

Transmitir os dados obtidos per a DRAGONBOARD 410c;

Seguiu un programa:

# include # define Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Període 60 unsigned int Scont = 0, SNow = PosServoMin; unsigned long int DAC [Numb_Sample], ind = Numb_Sample; void TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); si (Scont

1); // Cicle de treball del 50%

TC_SetRC (tc, canal, rc); TC_Start (tc, canal); tc-> TC_CHANNEL [canal]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // habilita os registradores tc-> TC_CHANNEL [channel]. TC_IDR = ~ (TC_IER_CPCS | TC_IER_CPAS); // desabilita os registradores NVIC_EnableIRQ (irq); // habilita interrupció}

configuració nul·la ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Inicieu el temporitzador // TC_Stop (TC1, 0); pinMode (SERVO, OUTPUT); }

bucle buit ()

{/ * // while (! Serial.available ()); char rc; // = Serial.read (); int índice = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); commutador (rc) {cas 1: índex = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indice << = 8; índex + = rc; while (! Serial.available ()); } Serial.print (0); Serial.print (2); SendNumber (DAC [índex]); Serial.print (0xFF); trencar; cas 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; retard (500); ind = 0; // TC_Start (TC1, 0); mentre que (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; retard (500); Serial.print (0); Serial.print (4); Serial.print (0xFF); } trencar; }} else if (rc == '2') {Serial.print ("Test Servo Motor / n"); while (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Mode 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Mode 2 / n"); SNow = PosServoMin; }} * / SNow = PosServoMax; retard (100); SNow = PosServoMin; retard (100); }

Pas 6: Interfaceamento Das Tecnologias

Per a una comunicació dos dies entre o Arduíno DUE ea DRAGONBOARD 410c, inicialment utilitzou-se a interface da figura acima, o que no va ser possible executar, então optou-se pelo uso de uma interface USB CDC entre o Arduino DUE ea DRAGONBOARD 410c, que necessitaria da recompilação do KERNEL da DRAGONBOARD 410c, que no es fes per causa do curto tempo disponível.

Pas 7: Configuració de DRAGONBOARD 410c (Python)

Va ser configurat per enviar a Arduino DUE els comandaments per a realitzar una aquisició de dats i transmetre els dados obtinguts. Segueix codi abaixo.

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

temps d'importació importació sèrie pandes com pd importació numpy com np

# Configuració de connexió serial

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

ser.isOpen ()

print ('Introduïu les vostres ordres a continuació. / r / nIntroduïu "exit" per sortir de l'aplicació.')

entrada = 1

while 1: input = input (">>") if input == 'exit': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comanda per a Arduino DUE realitzar a coleta dos dados ser.write (1) # Envia o ordre per a Arduino DUE transmitir os dados coletados

lista =

per a la gamma i (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)

Pas 8: INTERPRETAÇÓ DOS ARQUIVOS DE AUDIO

Per poder realitzar la primera anàlisi dos dats obtinguts atravessats del sensor, se fes necessària a la conversió dos arquius sense format WAV, fornecidos pelos alunos autores do TCC i col·laboradors do projecto, per a valors numèrics, que han utilitzat els nostres algoritmes d’anàlisi embarcats en DRAGONBOARD 410c. Per realitzar aquesta conversa va ser escrita amb un algoritme em PYTHON 3 que és o arquivo WAV i salva os dados do espectro em um arquivo CSV. O l'algoritmo utilitzat segueix abaixo i emexo per descarregar.

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.

# codificació: utf-8

# Leitura e conversão dos audios para csv

# MÓDULS UTILITZATS

import ona importació numpy com np importació pandes com pd importació matplotlib.pyplot com plt

# FUNÇÃO PARA CONVERTER WAV EM DADOS DO 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_s)) 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 (Time)], axis = 1) df.to_csv (file_name + '.csv', index = False) return df

# CARREGANDO DATA FRAME COM OS DADOS DO 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_vazamento.col '

# GRÀFIC DO ESPECTRO DE AUDIO

figura, (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 ()

Pas 9: Anàlisi Visual Do Sinal

Com o PYTHON 3 és realitzada a transformada de Fourier, aquest artifici matemàtic realitza una transformació del sinal del domini del temps per al domini da freqüència, on es torna a analitzar com a diverses freqüències, i les seves amplituds, que composen aquell sinal. Pel que fa a l'anàlisi visual del gràfic transformat de Fourier amb professionals amb sistemes específics de poder identificar una existència d'algun vazament na tubulação. Estes gràfics serviran per a la validació de les anàlisis realitzades pel algorisme de detecció automàtica.

Limitant o eixo das frequências entre 100Hz e 800Hz, fica claro a existencia de vazamentos quan se observen distúrbios nesse range de frequências.

# coding: utf-8 # Mòduls utilitzats per a processament transformat de Fourier

Import pandas as pd # 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 amplitudes n = len (y) # Comprimento do sinal k = np. arange (n) T = n / Fs frq = k / T frq = frq [rang (n // 2)] Y = np.fft.fft (y) / n Y = Y [rang (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) # Funció que realitza una càrrega dos dies de CSV i un funcionament de Fourier def read_csv (nom_fitxer, init, final): df = pd.read_csv (nom_arxiu + '.csv') df.columns = ['amp', ' temps '] delta = final-init si init * 44100> len (df) o final * 44100> len (df): init = (len (df) / 44100) -delta si init = 100) & (df [' freq '] <= 800)] mx = ordenat (df [' amp ']) print ("Média das amplitudes:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") imprimeu ("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 amplituds majors:", np.mean (mx [-10:]) // df ['amp']. mean () * 100, "%", sep = "") print ("Amplitud Maior:", np.mean (mx [-1:]) // df ['amp']. mean () * 100, " % ", sep =" ") read_csv ('Solo_com_Vazamento', 2, 10) # Exemple de gràfics per a vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Exemple de gràfics per a sem vazamento

Pas 10: Algoritmo Em R Per Extração Das Features Dos Dados

Utilitzeu un algoritme em per realitzar o processar i extraure les funcions (característiques) dos dados obtinguts.

Este primer algoritmo realiza uma extração identificada, onde é necessário saber se o arquivo de áudio tracta-se de uma amostra vazamento detectado ou não, isso per que os dados resultants desse process servir per a treinament da rede neural utilizada.

Per a quan el sistema estiver em manera d’operació amb un algoritme amb poc diferent serà executat, on no estigui lluny a un extração no identificat, gerent soment com a característiques sem uma identificació.

Estas features ou caraterísticas são propriedades acústicas compostas per diverses informações referentes ao espectro de áudio capturado, abaixo seguirá uma descrição (em englishês) destas features.

Aquest algoritme fa part d'un projecte projectat no disponible a GitHub i podeu ser objecte d'un accés d'aquest enllaç, fins i tot es va modificar per atender segons les especificacions del projecte.

El programari utilitzat per rodar o l'algoritme és gratuït, descarregueu l'interpretador R e do R Studio.

Característiques extraídas:

• freqüència mitjana: freqüència mitjana (en kHz)
• sd: desviació estàndard de freqüència
• mediana: freqüència mitjana (en kHz)
• P25: primer quantil (en kHz)
• Q75: tercer quantil (en kHz)
• IQR: rang interquantil (en kHz)
• esbiaixar: esbiaixar (vegeu la nota a la descripció specprop)
• kurt: curtosi (vegeu la nota a la descripció specprop)
• sp.ent: entropia espectral
• sfm: planitud espectral
• mode: mode freqüència
• centroid: freqüència centroid (vegeu specprop)
• peakf: freqüència màxima (freqüència amb major energia)
• meanfun: mitjana de freqüència fonamental mesurada a través del senyal acústic
• minfun: freqüència fonamental mínima mesurada a través del senyal acústic
• maxfun: freqüència fonamental màxima mesurada a través del senyal acústic
• meandom: mitjana de freqüència dominant mesurada a través del senyal acústic
• mindom: mínim de freqüència dominant mesurat a través del senyal acústic
• maxdom: màxim de freqüència dominant mesurada a través del senyal acústic
• dfrange: rang de freqüència dominant mesurat a través del senyal acústic
• modindx: índex de modulació. Calculat com la diferència absoluta acumulada entre mesures adjacents de freqüències fonamentals dividides pel rang de freqüències
• etiqueta: fuita o sense fuita

Algoritmo usat:

paquets <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'ratolins', 'e1071', 'rpart', 'xgboost', 'e1071') si (length (setdiff (packages, rownames (installed.packages ())))> 0) {install.packages (setdiff (paquets, rownames (installed.packages ())))}}

biblioteca (tuneR)

biblioteca (seewave) biblioteca (caTools) biblioteca (rpart) biblioteca (rpart.plot) biblioteca (randomForest) biblioteca (warbleR) biblioteca (ratolins) biblioteca (xgboost) biblioteca (e1071)

specan3 <- function (X, bp = c (0, 22), wl = 2048, threshold = 5, parallel = 1) {# Per utilitzar el processament en paral·lel: biblioteca (devtools), install_github ('nathanvan / parallelsugar') si (class (X) == "data.frame") {if (all (c ("sound.files", "selec", "start", "end")% en% 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", "inici", "final")% en% colnames (X))], collapse = ","), "columna (s) no trobades en el marc de dades"))} else stop ("X no és un marc de dades") # si hi ha NA a la parada inicial o final si (alguna (is.na (c (final, inici))))) parada ("NA es troba a l'inici i / o al final") # Si el final o l'inici no són una parada numèrica if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' i 'selec' han de ser numèrics") #if qualsevol inici superior a stop final si (any (end - start <0)) stop (paste ("L'inici és superior a l'en d en ", length (which (end - start20)) stop (paste (length (which (end - start> 20))," selection (s) long than 20 seg ")) opcions (show.error.messages = TRUE) #if bp no és vector ni longitud! = 2 stop si (! is.vector (bp)) stop ("'bp' ha de ser un vector numèric de longitud 2") else {if (! length (bp) == 2) stop ("'bp' ha de ser un vector numèric de longitud 2")} #return advertència si no s'han trobat tots els fitxers de so fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (length (unique (sound.files [(sound.files% in% fs)]))! = length (unique (sound.files))) cat (paste (length (unique (sound. files)) - length (unique (sound.files [(sound.files% in% fs)])), ".wav file (s) not found")) #count nombre de fitxers de so al directori de treball i si 0 s'atura d <- which (sound.files% in% fs) if (length (d) == 0) {stop ("Els fitxers.wav no estan al directori de treball")} else {start <- start [d] end <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Si el paral·lel no és numèric si (! is.numeric (parallel)) stop ("paral·lel" ha de ser ser un vector numèric de longitud 1 ") if (qualsevol (! (parallel %% 1 == 0), parallel 1) {options (warn = -1) if (all (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", quietly = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) else if (Sys.info () [1] == "Windows") {cat ("Els usuaris de Windows necessiten instal·lar el paquet 'parallelsugar' per a la informàtica paral·lela (ara no ho feu!)") Lapp <- pbapply:: pblapply} else lapp <- function (X, FUN) parallel:: mclapply (X, FUN, mc.cores = parallel)} else lapp <- pbapply:: pblapply options (warn = 0) if (parallel == 1) cat ("Measuring acoustic settings:") x <- as.data.frame (lapp (1: length (start), function (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), from = start , to = end , units = "seconds") b sostre ([email protected]/2000) - 1) b [2] <- sostre ([email protected]/2000) - 1 #frequency spectre analysis songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) anàlisi <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), diagrama = FALS) # guardar paràmetres meanfreq <- anàlisi $ mitjana / 1000 sd <- anàlisi $ sd / 1000 mediana <- anàlisi $ mediana / 1000 Q25 < - anàlisi $ QQ75 <- anàlisi $ QIQR <- anàlisi $ IQR / 1000 esbiaix <- anàlisi $ asimetria kurt <- anàlisi $ kurtosis sp.ent <- anàlisi $ sh sfm <- anàlisi $ mode sfm <- anàlisi $ mode / 1000 centroid <- anàlisi $ cent / 1000 #Freqüència amb pics d'amplitud pic <- 0 # seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] # Paràmetres de freqüència fonamentals ff <- seewave:: fund (r, f = [email protected], ovlp = 50, threshold = threshold, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] meanfun <-mean (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) # Paràmetres de freqüència dominants y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, diagrama = F, llindar = llindar, pas de banda = 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) duration <- (end - start ) #modulation càlcul índex canvis <- vector () per a (j en què (! is. na (y))) {change <- abs (y [j] - y [j + 1]) changes <- append (changes, change)} if (mindom == maxdom) modindx <-0 else modindx <- mean (canvis, na.rm = T) / dfrange #save results return (c (durada, freqüència mitjana, sd, mediana, Q25, Q75, IQR, inclinació, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #change result noms noms de pila (x) <- c ("durada", "meanfreq", "sd", "mediana", "Q25", "Q75", "IQR", "inclinat", "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") noms de pila (x) <- c (1: nrow (x)) return (x)}

processFolder <- function (folderName) {# Comenceu amb data.frame buit. data <- data.frame () # Obteniu la llista de fitxers de la carpeta. list <- list.files (folderName, '\. wav') # Afegeix una llista de fitxers a data.frame per al seu processament. per a (fileName a la llista) {fila <- data.frame (fileName, 0, 0, 20) data <- rbind (data, fila)} # Establir noms de columna. noms (dades) <- c ('sound.files', 'selec', 'start', 'end') # Mou a la carpeta per processar-la. setwd (folderName) # Fitxers de procés. acústica <- specan3 (dades, paral·lel = 1) # Torna a la carpeta pare. setwd ('..') acústica}

gender <- function (filePath) {if (! existeix ('genderBoosted')) {load ('model.bin')} # Camins de configuració. currentPath <- getwd () fileName <- nom de la base (filePath) camí <- dirname (filePath) # Estableix el directori per llegir el fitxer. setwd (ruta) # Comenceu amb data.frame buit. dades <- data.frame (fileName, 0, 0, 20) # Estableix els noms de les columnes. noms (dades) <- c ('sound.files', 'selec', 'start', 'end') # Processar fitxers. acústica <- specan3 (dades, paral·lel = 1) # Restaura el camí. setwd (currentPath) predict (genderCombo, newdata = acústica)}

# Carrega les dades

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

# Estableix etiquetes.

leakage $ label <- 1 without_ leakage $ label <- 2 data <- rbind (leakage, without_ leakage) data $ label <- factor (data $ label, labels = c ('leakage', 'without_ leakage'))

# Elimineu les columnes no utilitzades.

dades $ durada <- dades NULL $ fitxers de so <- dades NULL $ selec <- dades NULL $ peakf <- NULL

# Elimineu les files que contenen NA.

dades <- dades [complete.cases (dades),]

# Escriu el conjunt de dades CSV.

write.csv (dades, fitxer = 'features.csv', sep = ',', row.names = F)

Pas 11: Redueix la neurona

A ideia do use de uma rede neural, és a realitzar amb un reconeixement automatitzat através dos dados coletats de pèl dispositiu de sensoriament.

A rede neural utilizada é do tipo MLP (Multilayer Perceptron), this model is treinado with dados prèviament identificats e após esse treinamento o model implantado no sistema aconseguirá realizar a identificación automática do sinal recebido, informando se naquele ponto existe um vazamento o não.

Foi necessário realizado uma filtragem dos dados de entrada, pois algumas features estavam diminuindo a taxa de acerto da rede ao invés de melhora-la. Não foi realized nenhuma abordagem estatística muito aprofundada, mas even com um trabalho mais superficial can-you arrive to 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%, com pots ser observat en una imatge anexa.

Aquest algoritmo és utilitzat per treinar o model da rede i retornar a taxa d’acert do mateix. No sistema de detecção um algoritmo um little different seria used, pois ele realizaria o treino ou receberia um model já treinado da nuvem ou de alguma another fonte e com esse model realizaria as predições para cada leitura realizada.

# codificació: utf-8

importar pandes com a pd

importar numpy com np des de sklearn.model_selection importar train_test_split com tts des de sklearn.neural_network importar MLPClassifier com MLP des de sklearn.metrics importar classification_report com cr de sklearn.metrics importar confusion_matrix com 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

# Separando dados para treino e teste

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

# Criando model de rede neural

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

# Treinant model

modelo.fit (X_train, Y_train) result = model.predict (X_test)

# Imprimint resultats

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 Classificación") print (informe)