Sistema Autônomo Localizador De Vazamentos: 11 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:40

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 identifar e localizar, com o processamento dos dados por uma rede neural, possíveis vazamentos de água em uma tubulação.

A processamento destes dados é realizado por algoritmus instalados with DRAGONBOARD 410c. Os dados também são enviados para um serviço na nuvem, response to apuxilia 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), osallistás a projekt végzéséhez és az engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodor Gomes Polo és Ronaldo P. Gomes Polo. Também részt vesz a projektben vagy az életben Daniel de Castro Pacheco diploma és az 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 és Felipe Crispim da Silva Salvagnini.

1. lépés: Lista De Materiais

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

1 Arduino Due

1 Dragonboard 410c

2 Drivers para motor de corrente continua contendo cada um:

4 Transzmissziók BC548

4 Diodos 1n4007

4 Ellenáll 4k7Ω ¼ W

1 Illesztőprogram a szervomotorhoz:

1 Transistor BC548

1 Diodó 1N4007

1 Ellenáll a 4k7Ω ¼ W teljesítménynek

1 egér USB

1 Teclado USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini készítmény kremaléira és angol nyelvre

1 szervomotor 9g

2. lépés: Adaptação Mecânica

Para aquação dos dados pelo sensor piezoelétrico, faz se needsá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 trator de um tempó execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme video.

3. lépés: Acionamento Dos Motores

Végezze el a mozimentação dos motores do robô ZUMO e do dispositivo de captura, fez-se requiredária a monttagem 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 motor de corrente continua ea segunda o driver para um servo motor.

4. lépés: 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 detailshes sobre o TCC e podemos solisit e -mail: [email protected].

Használja a szenzor piezoelétrico és a placa de circuitito que realiza a filtragem e amplificação do sinal eszközöket.

Érdeklődési gyakoriság a 100 Hz és 800 Hz közötti projektekhez. 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, on a frequência de aquisição deve estar pelo menos duas vezes acima das freasadias.

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

5. lépés: Configuração Do Arduino DUE (C nyelv)

Devido a grande quantidade de dados, cerca de 3000 pontos por segundo, do tipo inteiro de 32 bit, gerados pelo dispositivo de sensoriamento e needsários para processamento dos algoritms na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada analógica com maior processzor, folyamat szükséges, vagy szükséges a Shield de interfaceamento Grove Seeed Sensor Mezzanine telepítéséhez a DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui poder de processamento para essa operação.

O Arduino DUE konfiguráció a vevőkészülékhez, amely kompatibilis a QUALCOMM DRAGONBOARD 410c -vel, comunicação serial segítségével.

Ações configuradas no Arduino foram:

Realizar a aquisição dos dados;

Adatátvitel a DRAGONBOARD 410c -hez;

Segítség a programhoz:

#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; 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); ha (Scont

1); // 50% -os működési ciklus

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

üres beállítás ()

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

üres hurok ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int index = 0; if (rc == 0) {while (! Serial.available ()); rc = Sorozat.olvasás (); kapcsoló (rc) {1. eset: index = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {index << = 8; index += rc; while (! Serial.available ()); } Soros.nyomtatás (0); Sorozatnyomat (2); SendNumber (DAC [index]); Sorozatnyomat (0xFF); szünet; 3. eset: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; késleltetés (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; késleltetés (500); Sorozatnyomtatás (0); Sorozatnyomat (4); Soros.nyomtatás (0xFF); } szünet; }} else if (rc == '2') {Serial.print ("Test Servo Motor / n"); while (! Serial.available ()); rc = Sorozat.olvasás (); if (rc == '1') {Serial.print ("1. mód / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("2. mód / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; késleltetés (100); SNow = PosServoMin; késleltetés (100); }

6. lépés: Interfaceamento Das Tecnologias

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 interface USB CDC entre o Arduino DUE ea DRAG szükség van a KERNEL da DRAGONBOARD 410c újragondolására, ez nem felel meg a tempónak.

7. lépés: Configuração Da DRAGONBOARD 410c (Python)

Az Arduino DUE konfigurációjának konfigurálása a DUE os comandos para realisar a aquisição de dados és a továbbító részekhez. Segue código abaixo.

Megfigyelés: 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 inkompatíveis. Ez az opcionális USB interfész, amely szükséges a KERNEL és a DRAGONBOARD 410c összeállításához, szükség esetén a kommunikációhoz.

import timeimport soros import pandák pd import numpy mint np

# Configuração da conexão sorozat

ser = soros. Soros (port = '/dev/ttyAMC0', #tty96B0 ', baudrate = 250000, paritás = soros. PARITY_NONE, stopbits = serial. STOPBITS_ONE, bytesize = serial. EIGHTBITS)

ser.isOpen ()

print ('Írja be az alábbi parancsokat. / r / nAz alkalmazásból való kilépéshez illessze be az "exit" parancsot.')

bemenet = 1

míg 1: input = input (">>") if input == 'exit': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comando para o Arduino DUE realar a coleta dos dados ser.write (1) # Envia o comando para o Arduino DUE broadcastir os dados coletados

lista =

i tartományban (3000):

ser.write (i/256)): atual << 8 atual += cc = ser.read (1) lista.append (atual)

8. lépés: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez needária and conversão 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 de anary embarg. Para realizar esta conversão foi escrito um algoritmo em PYTHON 3 que lê o arquivo WAV and salva os dados do espectro em um arquivo CSV. Töltse le az algoritmus segédprogramjait és töltse le őket.

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

# kódolás: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

import hullám import numpy mint np import pandák pd import matplotlib.pyplot mint plt

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

def audio_to_csv (fájlnév): 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') Idő = np.linspace (start = 0, stop = data_size/sample_rate, num = data_size, endpoint = True) df = pd.concat ([pd. DataFrame (jel), pd. DataFrame (Idő)], tengely = 1) df.to_csv (fájlnév + '.csv', index = Hamis) return df

# CARREGANDO ADATKERET COM OS DADOS DO AUDIO

file_name = 'Solo_com_Vazamento' df_vazamento = audio_to_csv (fájlnév) df_vazamento.columns = ['amp', 'time'] file_name = 'Solo_sem_Vazamento' df_sem_vazamento = audio_to_csv (fájlnév) df_sem_oszamvaz

# GRÁFICO DO ESPECTRO DE AUDIO

ábra, (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]) ábra.tight_layout (h_pad = 5) plt.show ()

9. lépés: Análise Visual Do Sinal

Com o PYTHON 3 é realizálja a Fourier átalakítását, art artificio matemático realiza a transformação do sinal do domínio do tempo para or 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 visual do gráfico da transformada de Fourier um profissional com conhecimentos específicos poderá identifar a pastência de algum vazamento na tubulação. Estes gráficos servirão para validção das análises realizadas pelo algoritmo de detecção automática.

Limitando o eixo das frequências entre 100Hz and 800Hz, fica claro a létező de vazamentos quando se observam distúrbios nesse range de frequências.

# kódolás: utf-8# Módosul utilizados para processamento da transformada de Fourier

import pandák mint pd import numpy, mint np import hullám a matplotlib import pyplot mint 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 ['time'] # Vetor de temppos y = y ['amp'] # Vetor de amplitudes n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [tartomány (n // 2)] Y = np.fft.fft (y)/n Y = Y [tartomány (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) ábra, ax = plt. részterületek (2, 1, figsize = (20, 10)) ax [0].plot (t, y) ax [0].set_xlabel ('Idő') 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)# Função que realiza a carga dos dados do CSV and chama a função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (fájlnév + '.csv') df.columns = ['amp', ' time '] delta = final-init if init*44100> len (df) or final*44100> len (df): init = (len (df)/44100) -delta, ha init = 100) & (df [' freq '] <= 800)] mx = rendezett (df [' amp ']) print ("Média das amplitudók:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") print ("100 maiores amplitud", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplitudó:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplitudó:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maior amplitúdó:", 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. lépés: Algoritmo Em R Para Extração Das Jellemzők 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 identifada, onde é needsá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 system estiver em modo de operação um algoritmo um pouco diferente será executado, onde não este fará and extração não identifada, gerando somente as características sem uma identifação.

Estas features ou caraterísticas são propriedades acústicas compostas por varias informationçõ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 szoftver, amelyet használhat, vagy ingyenes algoritmus, töltse le az R e do R Studio értelmezőjét.

Extra jellemzők:

• meanfreq: átlagos frekvencia (kHz -ben)
• sd: a frekvencia szórása
• medián: medián frekvencia (kHz -ben)
• Q25: első kvantilis (kHz -ben)
• Q75: harmadik kvantilis (kHz -ben)
• IQR: interkvantilis tartomány (kHz -ben)
• ferde: ferdeség (lásd a megjegyzést a specifikáció leírásában)
• kurt: kurtosis (lásd a megjegyzést a specifikáció leírásában)
• sp.ent: spektrális entrópia
• sfm: spektrális síkosság
• mód: módfrekvencia
• centroid: frekvencia centroid (lásd a specifikációt)
• peakf: csúcsfrekvencia (legnagyobb energiájú frekvencia)
• meanfun: az alapfrekvencia átlaga akusztikus jelben
• minfun: minimális alapfrekvencia akusztikus jelben mérve
• maxfun: maximális alapfrekvencia akusztikus jelben mérve
• meandom: az uralkodó frekvencia átlaga akusztikus jelben mérve
• mindom: az akusztikus jelben mért domináns frekvencia minimuma
• maxdom: az uralkodó frekvencia maximuma akusztikus jelben mérve
• dfrange: az uralkodó frekvencia tartománya az akusztikus jelben mérve
• modindx: modulációs index. Az alapfrekvenciák szomszédos mérései közötti halmozott abszolút különbségként kell kiszámítani, osztva a frekvenciatartománnyal
• címke: szivárgás vagy szivárgás nélkül

Algoritmo usado:

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

könyvtár (tuneR)

könyvtár (seewave) könyvtár (caTools) könyvtár (rpart) könyvtár (rpart.plot) könyvtár (randomForest) könyvtár (warbleR) könyvtár (egerek) könyvtár (xgboost) könyvtár (e1071)

specan3 <- függvény (X, bp = c (0, 22), wl = 2048, küszöb = 5, párhuzamos = 1) { # A párhuzamos feldolgozás használatához: könyvtár (devtools), install_github ('nathanvan/parallelsugar'), ha (class (X) == "data.frame") {if (all (c ("sound.files", "selec", "start", "end") % % -os oszlopnevekben (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 (beillesztés (c ("sound.files", "selec", "start", "end")) [! (c ("sound.files", "selec", "start", "end") % in % colnames (X))], collapse = ","), "oszlop (ok) nem találhatók az adatkeretben"))} else stop ("X nem adatkeret")) #ha vannak NA -k a kezdő vagy befejező állomáson, ha (bármely (is.na (c (vége, kezdet))))) stop ("NA -k a kezdetben és/vagy a végén") #ha a vége vagy a kezdete nem numerikus leállítás if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' és 'selec' számszerűnek kell lennie") #ha bármelyik kezdés magasabb, mint a végállomás, ha (any (end - start <0)) stop (paste ("A kezdet magasabb, mint az en d in ", hossz (amely (vége - kezdet20)) stop (beillesztés (hosszúság (amely (vége - kezdet> 20)))," 20 másodpercnél hosszabb kiválasztás (ok) ") lehetőségek (show.error.messages = TRUE) #ha bp nem vektor vagy hossz! = 2 stop, ha (! is.vector (bp)) stop ("" bp '2 hosszúságú numerikus vektornak kell lennie ") else {if (! length (bp) == 2) stop ("" bp '2 hosszúságú numerikus vektor kell, hogy legyen ")} #return figyelmeztetés, ha nem minden hangfájlt találtunk fs <- list.files (path = getwd (), pattern =".wav $ ", figyelmen kívül hagyni.eset = IGAZ) if (length (egyedi (sound.files [(sound.files % in % fs)]))! = = length (unique (sound.files))) cat (paste (length (egyedi (hang. fájlok))-hossz (egyedi (sound.files [(sound.files % % fs)])), ".wav fájl (ok) nem találhatók")) #hangfájlok száma a munkakönyvtárban, és ha 0 stop d <- amely (sound.files % % fs-ban) if (length (d) == 0) {stop (". A.wav fájlok nincsenek a munkakönyvtárban")} else {start <- start [d] end <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Ha a párhuzamos nem numerikus, ha (! is.numeric (parallel)) stop ("'parallel' must legyen 1 "hosszúságú numerikus vektor, ha (bármilyen (! (párhuzamos %% 1 == 0), párhuzamos 1) {options (Warn = -1) if (all (Sys.info () [1] ==" Windows ", needNamespace (" parallelsugar ", csendesen = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) else if (Sys.info () [1] == "Windows") {cat ("A Windows felhasználóknak telepíteniük kell a" parallelsugar "csomagot a párhuzamos számítástechnikához (most nem ezt teszi!)") 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 ("Akusztikus paraméterek mérése:") 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 #frekvencia spektrum elemzés songpec <- seewave:: spec (r, f = [email protected], plot = FALSE) elemzés <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #paraméterek mentése meanfreq <- elemzés $ átlagos/1000 sd <- elemzés $ sd/1000 medián <- elemzés $ medián/1000 Q25 < - elemzés $ QQ75 <- elemzés $ QIQR <- elemzés $ IQR/1000 ferdeség <- elemzés $ ferdeség kurt <- elemzés $ kurtosis sp.ent <- elemzés $ sh sfm <- elemzés $ sfm mód <- elemzés $ mode/1000 centroid <- elemzés $ cent/1000 #Frekvencia amplitúdó csúcsokkal peakf <- 0 #seewave:: fpeaks (songpec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Alapfrekvencia paraméterek ff <- seewave:: fund (r, f = [email protected], ovlp = 50, küszöb = küszöb, fmax = 280, ylim = c (0, 280/1000), plot = HAMIS, wl = wl) [, 2] meanfun <-mean (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Domináns gyakorisági paraméterek y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, küszöb = küszöb, sávszélesség = b * 1000, fftw = TRUE) [, 2] meandom <- átlag (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) duration <- (end - start ) #modulation index arvítás változások <- vector () for (j amelyben (! van. na (y))) {change <- abs (y [j]- y [j + 1]) changes <- append (changes, change)} if (mindom == maxdom) modindx <-0 else modindx <- átlag (változások, na.rm = T)/dfrange #save results return (c (időtartam, átlagfrekvencia, sd, medián, Q25, Q75, IQR, ferde, kurt, sp.ent, sfm, mód, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #Change results names rownames (x) <- c ("duration", "meanfreq", "sd", "median", "Q25", "Q75", "IQR", "ferde", "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 <- function (folderName) { # Kezdje az üres adatokkal.frame. data <- data.frame () # A mappában található fájlok listájának lekérése. list <- list.files (folderName, '\. wav') # Fájllista hozzáadása a data.frame-hez feldolgozásra. for (fileName in list) {row <- data.frame (fileName, 0, 0, 20) data <- rbind (adatok, sor)} # Oszlopnevek beállítása. nevek (adatok) <- c ('sound.files', 'selec', 'start', 'end') # Áthelyezés feldolgozandó mappába. setwd (folderName) # Fájlok feldolgozása. akusztika <- specan3 (adatok, párhuzamos = 1) # Vissza a szülőmappába. setwd ('..') akusztika}

gender <- function (filePath) {ha (! létezik ('genderBoosted')) {load ('model.bin')} # Beállítási útvonalak. currentPath <- getwd () fileName <- basename (filePath) elérési út <- dirname (filePath) # A könyvtár beállítása fájl olvasására. setwd (elérési út) # Kezdje az üres adatokkal.keret. data <- data.frame (fileName, 0, 0, 20) # Oszlopnevek beállítása. nevek (adatok) <- c ('sound.files', 'selec', 'start', 'end') # Fájlok feldolgozása. akusztika <- specan3 (adatok, párhuzamos = 1) # Visszaállítási útvonal. setwd (currentPath) előrejelzés (genderCombo, newdata = akusztika)}

# Adat betöltés

szivárgás <- processFolder ('caminho para o pasta com sample de áudio com vazamento') without_leakage <- processFolder ('caminho para o pasta com sample de áudio sem vazamento')

# Állítson be címkéket.

szivárgás $ label <- 1 nélkül_szivárgás $ címke <- 2 adat <- rbind (szivárgás, szivárgás nélkül) adatok $ label <- tényező (data $ label, labels = c ('szivárgás', 'szivárgás nélkül'))

# Távolítsa el a nem használt oszlopokat.

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

# Távolítsa el az NA -kat tartalmazó sorokat.

adatok <- adatok [teljes.esetek (adatok),]

# Írja ki a csv adatkészletet.

write.csv (adatok, fájl = 'features.csv', szept = ',', sor.nevek = F)

11. lépés: A neurális helyreállítása

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

A rede neural utilizada é do tipo MLP (Multilayer Perceptron), este modelo é treinado com dados previamente identifados e após esse treinamento o modelo implantado no system conseguirá realizar a identifação automática do sinal recebido, informando se naquele ponto existe um vazamento ou não.

Foi requiredá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 more felületes pode-se chegar a algumas variáveis com bons desempenhos.

Para os herék megvalósítása vagy modellje 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 algoritmus és hasznosítás a treinar vagy modelo da rede és retornar a taxa de acerto do mesmo. No system de detecção um algoritmo um um pouco diferente seria usado, pois el 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.

# kódolás: utf-8

importálja a pandákat pd -ként

importálja a numpy -t np -ként a sklearn.model_selection -ből import train_test_split tts -ként a sklearn.neural_network importból

# 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 modelo de rede neurális

modelo = MLP (alfa = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, aktiválás = 'tanh', megoldó = 'lbfgs')

# Treinando modelo

modelo.fit (X_train, Y_train) eredmény = modelo.predict (X_test)

# Imprimindo resultados

jelentés = cr (Y_test, eredmény) mat = cm (y_pred = eredmény, y_true = Y_test) print ("Matriz de confusão") print (mat, end = "\ n / n") print ("Relatório de Classificação") print (jelentés)