Vazamentose autonoomse asukoha süsteem: 11 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:47

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.

Ootame protsesside saatusi ja realiseerime DRAGONBOARD 410c installimise algoritmi. Os dados também são enviados para um serviço na nuvem, vastus lisaprotsessile integreerimata protsesside kunstlikuks tegemiseks.

Este projeto foi desenvolvido no Hackaton Qualcomm, durante a TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), programmis osalejate projektid ja engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodor Gomes Polo ja Ronaldo P. Gomes Polo. Também osaleb projektis või aluno Daniel de Castro Pacheco lõpetas ja engenharia mecânica na Universidade Newton Paiva de Belo Horizonte. Ootame, et saada ülevaade engenharia mecatrônica da FACENS, Lucas Nunes Monteiro ja Felipe Crispim da Silva Salvagnini lõpetustest.

Samm: Lista De Materiais

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

1 Arduino tähtaeg

1 Dragonboard 410c

2 draiverit, mis on mõeldud mootori korrapäraseks jätkamiseks:

4 Transistorid BC548

4 dioodi 1n4007

4 Resistres 4k7Ω ¼ W

1 juht servomootoriga:

1 Transistorid BC548

1 dioodid 1N4007

1 Resistres 4k7Ω ¼ W

1 USB -hiir

1 USB -teclado

1 Monitor

1 HDMI kaabel

1 Robô De Esteiras - Plataforma Zumo

1 väike kreemide ja ingliskeelne seade

1 servomootor 9g

2. samm: Adaptação Mecânica

Para ja aquisção dos dados pelo sensor piezoelétrico, faz se vajadus, või desenvolvimento de um dispositivo com pinhão e cremalheira, conforme desenhos anexados, neste caso as pecaas foram fabricadas por uma impressora 3D, devido ao fato de se trator de um täideviimise tempo, fikseerimine või paigutamine platoformaatesse, kasutusvõimalus kahe näo jaoks, video kinnitamine.

3. samm: Acionamento Dos Motores

Rakenduse ZUMO e-käsutusse andmine ja liikumapanevate juhtide juhtimine, vajadus montaaži ja autojuhtide vahelise montaaži jaoks, osade juhtimine para os motores de corrente continua e um driver para o servo engine, conforme as figuras acima, sendo a primeira figura or driver para um mootor de corrente continua ea segunda o juht para um servomootor.

4. samm: 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 ja Felipe C. da Silva Salvagnini, paljud üksikasjad sobra või TCC ja sobre oposit saatke e -kiri [email protected].

Kui kasutate seda sensorit piesoeleetriliseks ja vooluahelaks, saate realiseerida filtri ja võimendada seda.

Kuna sagedused on huvipakkuvad või on ette nähtud 100 Hz kuni 800 Hz. Para isso o dispositivo de sensoriamento for Configurado com uma frequência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, on frequência de aquisição deve estar pelo menos duas vezes acima das frequadnc.

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

Samm: Configuração Do Arduino DUE (keelekeel C)

Devido a grande quantidade de dados, cerca de 3000 täp por segundo, do tipo inteiro de 32 bit, gerados pelo dispositivo de sensoriamento e vajadused para processamento dosnos, DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada analógica com maior protsessor, protsessor on vajalik, sh Shield de interfaceamento Grove Seeed Sensor Mezzanine on paigaldatud DRAGONBOARD 410c, mikrokontrolaator ATmega 328, mis on võimeline töötama.

O Arduino DUE konfiguratsioonikomplektide vastuvõtjate jaoks, mis on enviados da plataforma QUALCOMM DRAGONBOARD 410c comunicação serial kaudu.

Ações configuradas no Arduino foram:

Realizar a aquisição dos dados;

DRAGONBOARD 410c edastusvõrk;

Programmi koostamine:

#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; allkirjastamata pikk int DAC [Numb_Sample], ind = Numb_Sample; tühine TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); kui (Scont

1); // 50% töötsükkel

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}

tühine seadistus ()

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

tühine tsükkel ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int indeks = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); lüliti (rc) {juhtum 1: indeks = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indeks << = 8; indeks += rc; while (! Serial.available ()); } Seeria.print (0); Seeriatrükk (2); SendNumber (DAC [indeks]); Seeriaprint (0xFF); murda; juhtum 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; viivitus (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; viivitus (500); Seeriatrükk (0); Seeriatrükk (4); Seeriaprint (0xFF); } murda; }} else if (rc == '2') {Serial.print ("Test Servo Motor / n"); while (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Režiim 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Režiim 2 / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; viivitus (100); SNow = PosServoMin; viivitus (100); }

6. samm: Interfaceamento Das Tecnologias

Selleks, et kasutada Arduíno DUE ea DRAGONBOARD 410c-d, käivitatakse kasutajaliides ja käivitatakse kasutajaliides, kus saab kasutada käivitusprogrammi, käivitatakse opsüsteem, CD-sisend või Arduino DUE ea DRAG KERNEL DRAGONBOARD 410c vajaliku kompoleerimise vajadus, see ei pruugi olla võimalik.

Samm 7: konfigureerimine Da DRAGONBOARD 410c (Python)

Arduino DUE konfiguratsiooni konfiguratsioon DUE osadeks, mis realiseerivad veekogud isadele ja saatjatele. Segue código abaixo.

Tähelepanu: 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 inkpatíveis. See on ka USB-liidese optiline liides, mille jaoks on vaja KERNELi ja DRAGONBOARD 410c kokkupanekut, kui see on ühendatud ja korrigeeritud.

impordi aegimport jadaimpordi pandad pd -vormingus import numpy kui np

# Seeriakonfiguratsioon

ser = jada. Seriaalne (port = '/dev/ttyAMC0', #tty96B0 ', baudrate = 250000, pariteet = jada. PARITY_NONE, stopbitid = seeria. STOPBITS_ONE, baitide suurus = jada. EIGHTBITS)

ser.isOpen ()

print ('Sisestage oma käsud allpool. / r / nRakendusest lahkumiseks sisestage käsk "exit".')

sisend = 1

samas kui 1: sisend = sisend (">>") kui sisend == 'väljumine': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comando para o Arduino DUE realis a coleta dos dados ser.write (1) # Envia o comando para või Arduino DUE saatja osad coletados

nimekiri =

i vahemikus (3000):

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

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

Para poder realizar uma primeira análise dos dados obtidos através do sensor, see fez vajadus ja vestlus arquivos no format WAV, fornecidos pelos alunos autores do TCC and colaboradores do projeto, para valores nummericos, que são utilizados nos algoritmos de analise DR. Kui soovite aru saada, milline on PYTHON 3 algoritmi algoritm, kirjutage WAV ja salv os dados do espectro em um arquivo CSV. Laadige alla algoritm, mida saab kasutada abiexo ja anexo jaoks.

Esse algoritm ei vaja faas vajadust para või funktsionaalne süsteem, mäng que või Arduino DUE mäng enviará esses dados em um array de valores numéricos.

# kodeerimine: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

impordi laine import numpy kui np import pandad kui pd import matplotlib.pyplot kui plt

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

def audio_to_csv (failinimi): 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') Aeg = np.linspace (algus = 0, peatus = andmete suurus/proovi_aste, arv = andmete suurus, lõpp -punkt = tõene) df = pd.concat ([pd. DataFrame (signaal), pd. DataFrame (Time)], telg = 1) df.to_csv (failinimi + '.csv', index = False) return df

# CARREGANDO ANDMETE RAAM COM OS DADOS DO AUDIO

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

# GRÁFICO DO ESPECTRO DE AUDIO

joonis, (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 ['aeg'], 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. samm: Visual Do Sinal analiseerimine

Com PYTHON 3 realiseerib Fourier'i ümberkujundamise, on kunstlik matemaatiline realiseerimine ja muutus sinal, et domineerida tempo või domineerida da frequência, on torna võimalike analüüside variandid, amplituudid, que compõem aqual sinal. Pela análise visual do do gráfico da transformada de Fourier um professional com conhecimentos específicos poderá identific 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.

Piirang või sagedus on 100 Hz kuni 800 Hz, see on eksisteeriv vazamentos quando se observam distúrbios nesse range de frequências.

# kodeerimine: utf-8# Muutusmeetod, mida kasutatakse Fourier'i teisendamise protsessis

impordi pandad kui pd import numpy kui np impordi laine matplotlibist impordi püplot kui plt# Função que realiza a transformada de Fourier ja plota os gráficos para análise def Fourier (df_list): Fs = 44100; # Taksod de amostragem em Hz Ts = 1,0/Fs; # Intervall de amostragem y = pd.concat (df_list) t = y ['time'] # Vetor de temppos y = y ['amp'] # Vetor de amplitudes n = len (y) # Comprimento to sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [vahemik (n // 2)] Y = np.fft.fft (y)/n Y = Y [vahemik (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) joonis, kirves = plt.alamplaadid (2, 1, joonise suurus = (20, 10)) kirv [0].plot (t, y) kirves [0].set_xlabel ('Aeg') kirves [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 () tagasipöördumine frq, abs (Y)# Função que realize a carga dos dados do CSV and chama a função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (failinimi + '.csv') df.columns = ['amp', ' aeg '] delta = lõplik-init, kui init*44100> len (df) või lõplik*44100> len (df): init = (len (df)/44100) -delta, kui init = 100) & (df [' sagedus '] <= 800)] mx = sorteeritud (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 amplitud", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplituud:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplituudi:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maiori amplituud:", np.mean (mx [-1:]) // df ['amp']. mean ()*100, " %", sep =" ") read_csv ('Solo_com_Vazamento', 2, 10) # Näide gráficos para vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Näide gráficos para sem vazamento

Samm 10: Algoritmo Em R Para Extração Das Features Dos Dados

Kasutage algoritmi R real realiseerimiseks või töötlemiseks ja lisavõimaluste (karakteristikute) jaoks.

Este algse algoritmi realiseerimine on täiendav identifikaator, mis on vajalik vajaduse korral, kui see on arvatav, ja see on vajalik, kui see on valesti, kui see on tuvastatud, iso por 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 funktsioonid ou caraterísticas são propriedades acústicas kompostas por varias informationções referentes ao espectro de áudio capturado, abaixo seguirá uma descrição (em inglês) destas características.

Este algoritm 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 tarkvara, mis on mõeldud kasutamiseks tasuta või tasuta algoritm, laadige alla tõlgendaja R e do R Studio.

Täiendavad omadused:

• meanfreq: keskmine sagedus (kHz)
• sd: sageduse standardhälve
• mediaan: keskmine sagedus (kHz)
• Q25: esimene kvantiil (kHz)
• Q75: kolmas kvantili (kHz)
• IQR: interkvantiline vahemik (kHz)
• kaldus: viltu (vt märkust spetsifikatsiooni kirjelduses)
• kurt: kurtosis (vt märkust spetsifikatsiooni kirjelduses)
• sp.ent: spektraalne entroopia
• sfm: spektraalne tasasus
• režiim: režiimi sagedus
• tsentroid: sagedus tsentroid (vt spetsifikatsiooni)
• peakf: tippsagedus (kõrgeima energiaga sagedus)
• meanfun: põhisageduse keskmine, mõõdetuna helisignaali kaudu
• minfun: minimaalne põhisagedus, mida mõõdetakse helisignaali kaudu
• maxfun: maksimaalne põhisagedus, mida mõõdetakse helisignaali kaudu
• meandom: domineeriva sageduse keskmine, mõõdetuna helisignaali kaudu
• mindom: minimaalne domineeriv sagedus, mida mõõdetakse helisignaali kaudu
• maxdom: domineeriva sageduse maksimum, mõõdetuna helisignaali kaudu
• dfrange: domineeriva sageduse vahemik, mida mõõdetakse helisignaali ulatuses
• modindx: modulatsiooni indeks. Arvutatakse kui kogunenud absoluutne erinevus põhisageduste kõrvuti asetsevate mõõtmiste vahel jagatuna sagedusvahemikuga
• silt: leke või ilma lekketa

Algoritmo:

paketid <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'hiired', 'e1071', 'rpart', 'xgboost', 'e1071') kui (pikkus (setdiff (paketid, rownames (install.packages ())))> 0) {install.packages (setdiff (paketid, rownames (install.packages ())))})

raamatukogu (tuneR)

raamatukogu (seewave) raamatukogu (caTools) raamatukogu (rpart) raamatukogu (rpart.plot) raamatukogu (randomForest) raamatukogu (warbleR) raamatukogu (hiired) raamatukogu (xgboost) raamatukogu (e1071)

specan3 <- funktsioon (X, bp = c (0, 22), wl = 2048, künnis = 5, paralleel = 1) { # Paralleelse töötlemise kasutamiseks: raamatukogu (devtools), install_github ('nathanvan/parallelsugar'), kui (class (X) == "data.frame") {if (kõik (c ("sound.files", "selec", "algus", "lõpp") % % veerunimedes (X))) {algus <- as.numeric (unlist (X $ algus)) lõpp <- as.numeric (unlist (X $ end)) sound.files <- as.character (unlist (X $ sound.files)) select <- as.character (unlist (X $ selec))} else stop (paste (paste (c ("sound.files", "selec", "algus", "lõpp") [! (c ("sound.files", "selec", "algus", "lõpp") % % -nimestes (X))], kollaps = ","), "veergu (d) ei leitud andmekaadrist"))} else stop ("X ei ole andmeraam")) #kui algus- või lõpp -peatuses on NA -sid, kui (mis tahes (is.na (c (lõpp, algus))))) stop ("NA -d leiti algusest ja/või lõpust") #kui lõpp või algus ei ole numbriline peatus if (kõik (klass (lõpp)! = "numbriline" & klass (algus)! = "numbriline")) stop ("" lõpp "ja" valik "peavad olema numbrilised") #kui mõni algus on kõrgem kui lõpp -peatus, kui (mis tahes (lõpp - algus <0)) stop (paste ("Algus on kõrgem kui en d in ", pikkus (mis (lõpp - algus20)) stop (kleepimine (pikkus (mis (lõpp - algus> 20)))," valik (ed) pikem kui 20 sekundit ") valikud (show.error.messages = TRUE) #kui bp ei ole vektor ega pikkus! = 2 stoppi, kui (! is.vector (bp)) stop ("'bp' peab olema arvuline vektor pikkusega 2") else {if (! length (bp) == 2) stop ("" bp 'peab olema numbriline vektor pikkusega 2 ")} #tagasipöördumise hoiatus, kui kõiki helifaile ei leitud fs <- list.files (path = getwd (), pattern =".wav $ ", ignoreerida.juht = TÕESE) if (pikkus (ainulaadne (sound.files [(sound.files % in % fs)])))! = pikkus (unikaalne (sound.files))) cat (paste (pikkus (ainulaadne (heli) failid))-pikkus (unikaalne (sound.files [(sound.files % % fs)])), ".wav-faili ei leitud")) #helifailide arv töökataloogis ja kui 0 stoppi d <- mis (sound.files % % fs) kui (pikkus (d) == 0) {stop (".wav-failid pole töökataloogis")} muu {algus <- algus [d] lõpp <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Kui paralleel ei ole numbriline, kui (! on.numbriline (paralleelne)) stop ("'paralleelne" peab olla numbriline vektor pikkusega 1 ") if (ükskõik (! (paralleelne %% 1 == 0), paralleel 1) {valikud (hoiatus = -1) kui (kõik (Sys.info () [1] ==" Windows ", vajaNamespace (" parallelsugar ", vaikselt = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = paralleel) else if (Sys.info () [1] == "Windows") {cat ("Windowsi kasutajad peavad paralleelse andmetöötluse jaoks installima paketi" parallelsugar "(te ei tee seda praegu!)") Lapp <- pbapply:: pblapply} else lapp <- funktsioon (X, FUN) paralleel:: mclapply (X, FUN, mc.cores = paralleel)} else lapp <- pbapply:: pblapply valikud (hoiata = 0) if (paralleel == 1) cat ("Akustiliste parameetrite mõõtmine:") x <- as.data.frame (lapp (1: pikkus (algus), funktsioon (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), alates = algus , lõpuni , ühikud = "sekundid") b ülemmäär ([email protected]/2000) - 1) b [2] < - ülemmäär ([email protected]/2000) - 1 #sagedusspektri analüüs songpec <- seewave:: spec (r, f = [email protected], plot = FALSE) analüüs <- seewave:: specprop (songpec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #save parameetrid meanfreq <- analüüs $ keskmine/1000 sd <- analüüs $ sd/1000 mediaan <- analüüs $ mediaan/1000 Q25 < - analüüs $ QQ75 <- analüüs $ QIQR <- analüüs $ IQR/1000 viltune <- analüüs $ viltus kurt <- analüüs $ kurtosis sp.ent <- analüüs $ sh sfm <- analüüs $ sfm režiim <- analüüs $ mode/1000 tsentroid <- analüüs $ cent/1000 #Sagedus amplituudi tippudega peakf <- 0 #seewave:: fpeaks (lauluspetsiif, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Põhisageduse parameetrid ff <- seewave:: fund (r, f = [email protected], ovlp = 50, künnis = lävi, 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) #Domineerivad sageduse parameetrid y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, künnis = lävi, ribapääs = b * 1000, fftw = TRUE) [, 2] meandom <- keskmine (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) kestus <- (end - algus ) #modulatsiooniindeksi arvutuse muutused <- vektor () jaoks (j milles (! on. na (y))) {muutma <- abs (y [j]- y [j + 1]) muudatused <- lisama (muutma, muutma)} kui (mindom == maxdom) modindx <-0 muu modindx <- keskmine (muutused, na.rm = T)/dfrange #save results return (c (kestus, keskmine sagedus, sd, mediaan, Q25, Q75, IQR, viltune, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #muuda tulemuste nimesid rownames (x) <- c ("duration", "meanfreq", "sd", "mediaan", "Q25", "Q75", "IQR", "viltune", "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))) kolonninimed (x) [1: 2] <- c ("sound.files", "selec") rownames (x) <- c (1: nrow (x)) return (x)}

processFolder <- funktsioon (kaustaNimi) { # Alustage tühjade andmetega.raam. andmed <- data.frame () # Hankige kaustas olevate failide loend. list <- list.files (kaustaNimi, '\. wav') # Lisa faililoend töötlemiseks data.frame. for (failinimi loendis) {rida <- data.frame (failinimi, 0, 0, 20) andmed <- rbind (andmed, rida)} # Määra veerunimed. nimed (andmed) <- c ('sound.files', 'selec', 'algus', 'lõpp') # Liigutage töötlemiseks kausta. setwd (folderName) # Töötle faile. akustika <- specan3 (andmed, paralleel = 1) # Liigu tagasi vanemkausta. setwd ('..') akustika}

sugu <- funktsioon (filePath) {kui (! olemas ('genderBoosted')) {load ('model.bin')} # Seadistusrajad. currentPath <- getwd () fileName <- basename (filePath) tee <- dirname (filePath) # Määra kataloog faili lugemiseks. setwd (tee) # Alustage tühjade andmetega.raam. andmed <- data.frame (fileName, 0, 0, 20) # Määra veerunimed. nimed (andmed) <- c ('sound.files', 'selec', 'start', 'end') # Failide töötlemine. akustika <- specan3 (andmed, paralleel = 1) # Taasta tee. setwd (currentPath) ennustada (genderCombo, newdata = akustika)}

# Laadige andmed

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

# Määrake sildid.

leke $ silt <- 1 ilma lekketa $ silt <- 2 andmed <- rbind (leke, ilma lekketa) andmed $ silt <- tegur (andmed $ silt, sildid = c ('leke', 'ilma lekketa'))

# Eemaldage kasutamata veerud.

andmed $ kestus <- NULL andmed $ sound.files <- NULL andmed $ selec <- NULL andmed $ peakf <- NULL

# Eemaldage read, mis sisaldavad NA -sid.

andmed <- andmed [täielikud. juhtumid (andmed),]

# Kirjutage csv -andmestik välja.

write.csv (andmed, fail = 'features.csv', sep = ',', row.names = F)

Samm 11: Rede Neural

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

A rede neural utilizada é do tipo MLP (Multilayer Perceptron), model and treinado com dados previamente identificos and após esse treinamento o modelo implantado no system secguirá realizar a identification of automateica do sinal recebido, informando se naquele ponto existe um vazamento ou não.

Kui see on vajalik, tuleb 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 pindmine pode-se chegar ja algumas varieveis com bons desempenhos.

Para os munandid realiseerida või mudeli obteve um desempenho muito bom, alcançando na maioria dos testes uma taxa de acerto de 100%, como pode ser obsadoado and imagem anexa.

Este algoritm ja kasutusvõimalused, mis on mõeldud treidi või mudeli kasutamiseks ja 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.

# kodeerimine: utf-8

importida pandasid kui pd

importi numpy np -na sklearn.model_selection import rongi_test_split tts -st sklearn.neural_network import MLPClassifier kui MLP sklearn.metrics impordi klassifikatsiooni_aruanne kui kr alates sklearn.metrics import segaduse_maatriks cm -na

# Leidura 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 neurode modell

modelo = MLP (alfa = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, aktiveerimine = 'tanh', lahendaja = 'lbfgs')

# Treinando modell

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

# Imprimindo resultados

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