Sistema Autônomo Localizador De Vazamentos: 11 Steps

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Este proiectat constă în um robo, că através da leitura realizată pentru un dispozitiv, echipat cu um sensor piezoelétrico, captura os spectros das vibrações no solo, poate identifica și localiza, com o procesament dos dados por uma rede neural, possíveis vazamentos de água em uma tubulação.

O procesare a acestor date este realizată de algoritmi instalați în DRAGONBOARD 410c. Os dados prea são enviados pentru um serviço na nuem, responsável por auxiliar no process de Integência Artificial do projeto.

Este proiectul a fost dezvoltat no Hackaton Qualcomm, în timpul unui TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), participam la proiecte os gradandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigues, Rogério Ap. Gomes Polo e Ronaldo P. Gomes Polo. Também participou do projeto o aluno Daniel de Castro Pacheco graduando de engenharia mecânica na Universidade Newton Paiva de Belo Horizonte. O proiect contou com o sprijin dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro e Felipe Crispim da Silva Salvagnini.

Step 1: Lista De Materiais

Pentru realizarea acestui proiect, pentru următoarele materiale folosite:

1 Arduino Due

1 Dragonboard 410c

2 Drivers pentru motor de curent continuă continuând fiecare um:

4 tranzistoare BC548

4 Diodos 1n4007

4 Rezistoare 4k7Ω ¼ W

1 Driver pentru servomotor contend:

1 Transistore BC548

1 Diodos 1N4007

1 Rezistoare 4k7Ω ¼ W

1 mouse USB

1 Teclado USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispozitiv de cremalheira și engrenagem

1 servomotor 9g

Pasul 2: Adaptação Mecânica

Para a aquisição dos dados pelo sensor piezoelétrico, faz se needário, o development de um device com pinhão e cremalheira, conforme desenhos anexados, neste case as peças foram fabricadas por uma impressora 3D, devido ao fato de se trata de um prototip e ao curto tempo de execução, fixou-se o dispozitiv na platforma zumo, folosind fita dupla face, conforme video.

Pasul 3: Acionamento Dos Motores

Pentru executarea a mișcării două motoare do robo ZUMO și do dispozitiv de captură, fez-se necesită a montaj de dois drivers pentru os motores de curent continuu și um driver pentru o servo motor, conforme as figuras acima, sendo a prima figura o driver para um motor de curent continuu ea a doua o driver pentru um servo motor.

Pasul 4: Obțineți Do Áudio

Pentru obținerea spectrului de áudio das vibrações do solo, a fost utilizat cu dispozitiv dezvoltat ca parte a TCC de Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro e Felipe C. da Silva Salvagnini, maiores detalhes sobre o TCC e sobre o dispozitiv putem să fie solicitate através do trimiteți un e-mail la [email protected].

Acest dispozitiv utilizează-se de um sensor piezoelétrico și uma placa de circuit care realizează filtrarea și amplificarea do sinal.

As frequências de interesse for o projecteto estão between 100Hz e 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, unde a frequência de aquisição deve estar pelo less duas vezes acima das frequências studadas.

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

Pasul 5: Configuração Do 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, a fost utilizat sau Arduino DUE pentru fazer uso de uma entrada analógica com maior puterea de procesare, acesta a fost necesar pentru care o Shield de interfațare Grove Seeed Sensor Mezzanine instalat în DRAGONBOARD 410c, care să aibă un microcontrolator ATmega 328, nu să aibă putere de procesare pentru a fi operațiune.

O Arduino DUE a fost configurat pentru primirea comenzilor trimise de pe platforma QUALCOMM DRAGONBOARD 410c prin comunicație serial.

Așa cum este configurat în Arduino foram:

Realiza a aquisição dos dados;

Transmitir os dados obtidos para a DRAGONBOARD 410c;

Urmăriți un program:

# include # define Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Perioada 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); dacă (Scont

1); // Ciclul de funcționare de 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 interrupção}

configurare nulă ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Inițierea temporizatorului // TC_Stop (TC1, 0); pinMode (SERVO, OUTPUT); }

bucla nulă ()

{/ * // while (! Serial.available ()); char rc; // = Serial.read (); int indice = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); switch (rc) {caz 1: indice = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indice << = 8; indice + = rc; while (! Serial.available ()); } Serial.print (0); Serial.print (2); SendNumber (DAC [indice]); Serial.print (0xFF); pauză; caz 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; întârziere (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; întârziere (500); Serial.print (0); Serial.print (4); Serial.print (0xFF); } pauză; }} else if (rc == '2') {Serial.print ("Testare servomotor / n"); while (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Modul 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Modul 2 / n"); SNow = PosServoMin; }} * / SNow = PosServoMax; întârziere (100); SNow = PosServoMin; întârziere (100); }

Pasul 6: Interfaceamento Das Tecnologias

Pentru o comunicație dos dados între o Arduíno DUE ea DRAGONBOARD 410c, inițial utiliz-se o interfață de la figura acima, care nu a fost posibil să se execute, então optou-se pelo uso de interface USB CDC entre o Arduino DUE ea DRAGONBOARD 410c, necessitaria da recompilação do KERNEL da DRAGONBOARD 410c, care nu se fez pe cauza do curto tempo disponível.

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

Foi configurado para enviar al Arduino DUE os commandos para realizar a aquisição de dados și transmitir os dados obtidos. Segue código abaixo.

Observație: A abordare utilizată fără cod, fără funcționare deviată către niveși de tensiune utilizată pelo Arduíno DUE e o Mezzanine serem incompatíveis. Por isso optou-se pelo interfaceamento USB, that necessitaria da recompilação do KERNEL na DRAGONBOARD 410c for that a porta fosse criada corretamente for a comunicação.

Timp de import

# Configuração da conexão serial

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

ser.isOpen ()

print ('Introduceți comenzile dvs. mai jos. / r / nIntroduceți „exit” pentru a părăsi aplicația.')

intrare = 1

while 1: input = input (">>") if input == 'exit': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comandă pentru Arduino DUE realiza a coleta dos dados ser.write (1) # Envia o comandă pentru o Arduino DUE transmite os dados coletados

lista =

pentru i în intervalul (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)

Pasul 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Pentru a putea efectua prima analiză a dosarelor obținute, através do sensor, se fez nevoie de conversia dosarelor fără format WAV, furnizate pelos alunos autores do TCC și colaboratori do project, pentru valori numerice, care s-au folosit noi algoritmi de analiză embarcados na DRAGONBOARD 410c. Pentru realizarea acestei conversații a fost scris în algoritmul PYTHON 3 care este o arquivo WAV și salva os dados do spectro em um arquivo CSV. O algoritmo utilizado segue abaixo și emexo pentru download.

Esse algoritmo não se faz necessário for o functionamento do system, já that o Arduino DUE já sendá esses dados em um array de valores numéricos.

# codificare: utf-8

# Leitura e conversație dos audio pentru csv

# MÓDULOS UTILIZADOS

import val import numpy ca np import panda ca pd import matplotlib.pyplot ca 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ÁFICO 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 ()

Pasul 9: Analizați vizual Do Sinal

Com o PYTHON 3 é realizada a transformada de Fourier, este artificio matemático realizează o transformare do sinal do domínio do tempo para o domínio da frequência, unde se revine posibil analisar as varias frequências, e suas amplitudes, that compõem aquele sinal. Pela analiza vizuală a graficului transformat de Fourier um profisional cu conținuturi specifice puteri identificare a existenței de algum vazament na tubulație. Estes graphics servirão for validação das analises realizadas pelo algoritmo de detecção automática.

Limitando o eixo das frequências între 100Hz e 800Hz, fica clear a existência de vazamentos when se observam distúrbios nesse range de frequências.

# coding: utf-8 # Módulos utilizados for processamento from transformada de Fourier

import pandas as pd import numpy as np import wave from matplotlib import pyplot as plt # Funcția care realizează o transformare de Fourier și plota os grafice pentru analiza 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 amplitudes n = len (y) # Comprimento do sinal k = np. aranjament (n) T = n / Fs frq = k / T frq = frq [interval (n // 2)] Y = np.fft.fft (y) / n Y = Y [interval (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) # Funcția care realizează o încărcare de date cu CSV și o funcție de Fourier def read_csv (file_name, init, final): df = pd.read_csv (file_name + '.csv') df.columns = ['amp', ' time '] delta = final-init if init * 44100> len (df) or final * 44100> len (df): init = (len (df) / 44100) -delta if init = 100) & (df [' freq '] <= 800)] mx = sortat (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 amplitudini mai mari:", 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) # Exemplu de grafice pentru vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Exemplu de grafice pentru sem vazamento

Pasul 10: Algoritmo Em R Pentru Extração Das Features Dos Dados

Utilizați-vă un algoritm în R pentru realizarea procesului și extrașionarea caracteristicilor (caracteristici) a dosarelor obținute.

Este primul algoritm realizează un extrațiu identificat, unde este necesar să se știe arquivo de áudio trata-se de uma amostra vazamento detectado ou não, isso por care os dados resultantes desse process servirão para o treinamento da rede neural utilizada.

Pentru când o sistemă este în funcțiune de funcționare cu un algoritm cu puțin diferit va fi executat, unde nu se poate face acest lucru extraordinar fără identificare, așa cum se caracterizează sem uma identificare.

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

Acest algoritm fază parte a unui proiect disponibil nu în GitHub și puteți fi accesat atras de acest link, sau chiar a fost modificat pentru atender ca specificații de proiectare.

O aplicație utilizată pentru rodare sau algoritmul este gratuit, descărcați interpretorul R e do R Studio.

Caracteristici extraídas:

• frecvență medie: frecvența medie (în kHz)
• sd: abaterea standard a frecvenței
• mediană: frecvența mediană (în kHz)
• Q25: prima cuantilă (în kHz)
• Q75: a treia cuantilă (în kHz)
• IQR: interval interquantil (în kHz)
• skew: asimetrie (vezi nota din descrierea specprop)
• kurt: kurtosis (vezi nota din descrierea specprop)
• sp.ent: entropie spectrală
• sfm: planeitate spectrală
• mod: frecvența modului
• centroid: frecvență centroid (vezi specprop)
• peakf: frecvența de vârf (frecvența cu cea mai mare energie)
• meanfun: medie a frecvenței fundamentale măsurate pe semnalul acustic
• minfun: frecvența fundamentală minimă măsurată pe semnalul acustic
• maxfun: frecvența fundamentală maximă măsurată pe semnalul acustic
• medie: medie a frecvenței dominante măsurată pe semnalul acustic
• mindom: frecvența minimă dominantă măsurată pe semnalul acustic
• maxdom: frecvența maximă dominantă măsurată pe semnalul acustic
• dfrange: intervalul de frecvență dominantă măsurat pe semnalul acustic
• modindx: indice de modulație. Calculat ca diferență absolută acumulată între măsurători adiacente ale frecvențelor fundamentale împărțite la gama de frecvențe
• etichetă: scurgere sau fără scurgere

Algoritmo folosit:

pachete <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'mouse', 'e1071', 'rpart', 'xgboost', 'e1071') dacă (lungime (setdiff (pachete, nume de redenume (installed.packages ())))> 0) {install.packages (setdiff (pachete, nume de redenume (installed.packages ())))}}

bibliotecă (tuneR)

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

specan3 <- funcție (X, bp = c (0, 22), wl = 2048, prag = 5, paralel = 1) {# Pentru a utiliza procesarea paralelă: bibliotecă (devtools), install_github ('nathanvan / parallelsugar') dacă (class (X) == "data.frame") {if (all (c ("sound.files", "selec", "start", "end")% în% 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", "select", "start", "end") [! (c ("sound.files", "selec", "start", "end")% în% colnames (X))], collapse = ","), "column (s) not found in data frame"))} else stop ("X nu este un cadru de date") #dacă există NA în start sau sfârșit dacă (orice (is.na (c (end, start))))) stop ("NA găsite în start și / sau sfârșit") # dacă end sau start nu sunt stop numeric if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' și 'selec' trebuie să fie numerice") # if any start higher than end stop if (any (end - start <0)) stop (paste ("Startul este mai mare decât en d în ", lungime (care (sfârșit - început20)) oprire (lipire (lungime (care (sfârșit - început> 20))," selecție (e) mai mare de 20 sec ")) opțiuni (show.error.messages = TRUE) #if bp nu este vector sau lungime! = 2 opriți dacă (! este.vector (bp)) opriți („„ bp”trebuie să fie un vector numeric de lungime 2”) else {if (! lungime (bp) == 2) stop ("'bp' trebuie să fie un vector numeric de lungime 2")} #return avertisment dacă nu au fost găsite toate fișierele de sunet fs <- list.files (cale = getwd (), model = ".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 numărul de fișiere audio în directorul de lucru și dacă 0 se oprește d <- care (sound.files% în% fs) if (length (d) == 0) {stop ("Fișierele.wav nu sunt în directorul de lucru")} else {start <- start [d] end <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Dacă paralela nu este numerică dacă (! is.numeric (parallel)) stop ("'parallel' trebuie fii un vector numeric de lungime 1 ") if (oricare (! (paralel %% 1 == 0), paralel 1) {opțiuni (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 ("Utilizatorii Windows trebuie să instaleze pachetul 'parallelsugar' pentru calcul paralel (nu o faceți acum!)") 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 ("Măsurarea parametrilor acustici:") 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 plafon ([email protected]/2000) - 1) b [2] <- plafon ([email protected]/2000) - 1 #analiza spectrului de frecvență songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analiză <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #save parameters meanfreq <- analysis $ mean / 1000 sd <- analysis $ sd / 1000 median <- analysis $ median / 1000 Q25 < - analiză $ QQ75 <- analiză $ QIQR <- analiză $ IQR / 1000 înclinare <- analiză $ skewness kurt <- analiză $ kurtosis sp.ent <- analiză $ sh sfm <- analiză $ sfm mode <- analiză $ mode / 1000 centroid <- analiză $ cent / 1000 # Frecvență cu vârfuri de amplitudine peakf <- 0 # seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] # Parametri de frecvență fundamentali ff <- seewave:: fund (r, f = [email protected], ovlp = 50, prag = prag, fmax = 280, ylim = c (0, 280/1000), diagramă = FALS, wl = wl) [, 2] meanfun <-mean (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) # Parametri de frecvență dominanți y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, prag = prag, 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) durata <- (end - start ) #modulation index changes calcul <- vector () pentru (j în care (! este. na (y))) {change <- abs (y [j] - y [j + 1]) changes <- append (changes, change)} if (mindom == maxdom) modindx <-0 else modindx <- mean (modificări, na.rm = T) / dfrange #save results return (c (durata, meanfreq, sd, mediană, Q25, Q75, IQR, skew, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #change result names rownames (x) <- c ("duration", "meanfreq", "sd", "median", "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") nume de nume (x) <- c (1: nrow (x)) return (x)}

processFolder <- function (folderName) {# Începeți cu data.frame gol. data <- data.frame () # Obțineți lista de fișiere din folder. list <- list.files (folderName, '\. wav') # Adăugați lista de fișiere în data.frame pentru procesare. for (fileName in list) {rând <- data.frame (fileName, 0, 0, 20) data <- rbind (data, rând)} # Setați numele coloanelor. nume (date) <- c ('sound.files', 'selec', 'start', 'end') # Mutați în folder pentru procesare. setwd (folderName) # Procesare fișiere. acustică <- specan3 (date, paralel = 1) # Mutați înapoi în folderul părinte. setwd ('..') acustica}

gender <- function (filePath) {if (! exist ('genderBoosted')) {load ('model.bin')} # Setare căi. currentPath <- getwd () fileName <- nume de bază (filePath) cale <- dirname (filePath) # Setați directorul pentru a citi fișierul. setwd (cale) # Începeți cu data.frame gol. date <- data.frame (fileName, 0, 0, 20) # Setați numele coloanelor. nume (date) <- c ('sound.files', 'selec', 'start', 'end') # Procesare fișiere. acustică <- specan3 (date, paralel = 1) # Restaurare cale. setwd (currentPath) predict (genderCombo, newdata = acoustics)}

# Incarca date

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')

# Setați etichete.

scurgere $ etichetă <- 1 fără scurgere $ etichetă <- 2 date <- rbind (scurgere, fără scurgere) date $ etichetă <- factor (date $ etichetă, etichete = c ('scurgere', 'fără scurgere'))

# Eliminați coloanele neutilizate.

date $ durata <- NULL date $ sound.files <- NULL data $ selec <- NULL data $ peakf <- NULL

# Eliminați rândurile care conțin NA.

date <- date [complete.cases (data),]

# Scrieți setul de date CSV.

write.csv (date, fișier = 'features.csv', sep = ',', row.names = F)

Pasul 11: Rede Neural

A ideia do use de uma rede neural, is a de realiz um reconhecimento automatizat através dos dados coletados pelo device de sensoriamento.

A rede neural utilizada é do tipo MLP (Multilayer Perceptron), this model is treinado with dados previamente identifieds and após esse treinamento o model implantado no system conseguirá realizate a identification automática do sinal recebido, informando se naquele ponto existe um vazamento ou não.

Foi necessário realizat 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 realizado nenhuma abordagem estatística muito aprofundada, mas mesmo com um trabalho mais superficial can-se ajunge 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 taxons de acerto de 100%, cum puteți fi observat în imaginea anexă.

Acest algoritm este folosit pentru treinarul sau modelul de redare și returnare a taxelor de acerto do mesmo. 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.

# codificare: utf-8

import panda ca pd

import numpy as np from sklearn.model_selection import train_test_split as tts from sklearn.neural_network import MLPClassifier as MLP from sklearn.metrics import classification_report as cr from sklearn.metrics import confusion_matrix as 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')

# Treinando modelo

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

# Imprimindo rezultate

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