Automātiskā lokalizācijas sistēma Vazamentos: 11 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:54

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.

O processamento destes dados é realizado por algoritms instalados with DRAGONBOARD 410c. Os dados também são enviados para um serviço na nuvem, atbildes reakcija uz palīgprocesu bez integrācijas procesa mākslīgā do projeto.

Este projeto foi desenvolvido no Hackaton Qualcomm, durante and TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), piedalīšanās projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrose Gomes Polo un Ronaldo P. Gomes Polo. Tambēms piedalās projektēšanā vai mūža sākumā Daniela de Kastro Pačeko absolvēšanā un enģenārijas mecânica un Universidade Newton Paiva de Belo Horizonte. O projeto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro un Felipe Crispim da Silva Salvagnini.

1. darbība: Lista De Materiais

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

1 Arduino termiņš

1 Dragonboard 410c

2 draiveri para motor de corrente continua contendo cada um:

4 Transistori BC548

4 diodes 1n4007

4 Resistres 4k7Ω ¼ W

1 Vadītājs ar servomotoru:

1 Transistori BC548

1 Diodes 1N4007

1 Resistres 4k7Ω ¼ W

1 pele USB

1 USB teclado

1 Monitors

1 kabelis HDMI

1 Robô De Esteiras - Plataforma Zumo

1 mini krematēra un angļu valoda

1 servomotors 9g

2. darbība: Adaptação Mecânica

Para a aquisiçã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 pecaas foram fabricadas por uma impressora 3D, devido ao fato de se trator de um execução temp, fixou-se or dispositivo na plataforma zumo, utilizando fita dupla face, conforme video.

3. darbība: Acionamento Dos Motores

Lai izpildītu un pārvietotu motorus, ZUMO e do dispositivo de captura, fez-se nepieciešamība un montāža 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 vadītājs para um servo motor.

4. solis: 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, vairāk informācijas e -pasts [email protected].

Este utilitivo-se de um sensor pjezoelektriskā un uma placa de circuitito que realiza un filtragem e amplificação do sinal.

Kā frekvences intereses para vai projeto estão entre 100Hz un 800Hz. Para isso o dispositivo de sensoriamento foi configurarado com uma frequência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, onde 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. darbība. Configuração Do Arduino DUE (lingv. C)

Devido a grande quantidade de dados, cerca de 3000 täps por segundo, do tipo inteiro de 32 bit, gerados pelo dispositivo de sensoriamento e needários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada analógica com maior procesors, kā arī nepieciešamība pēc šīs shēmas vai vairoga saskarnes Grove Seeed Sensor Mezzanine, kas uzstādīts DRAGONBOARD 410c, kā arī mikrokontrolators ATmega 328, nav pieejams processer process.

O Arduino DUE konfigurācijas konfigurācija, kas paredzēta uztvērējiem, kas ir enviados da plataforma QUALCOMM DRAGONBOARD 410c, izmantojot comunicação serial.

Kā konfigurācija bez Arduino formas:

Realizar a aquisição dos dados;

Pārraides ierīces, kas paredzētas DRAGONBOARD 410c;

Izveidojiet programmu:

#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; neparakstīts garš int DAC [Numb_Sample], ind = Numb_Sample; void TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); ja (Scont

1); // 50% darba cikls

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

anulēts iestatījums ()

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

tukša cilpa ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int indekss = 0; if (rc == 0) {while (! Serial.available ()); rc = Sērijas.lasījums (); slēdzis (rc) {1. gadījums: indekss = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indekss << = 8; indekss += rc; while (! Serial.available ()); } Sērijas nospiedums (0); Sērijas nospiedums (2); SendNumber (DAC [indekss]); Sērijas nospiedums (0xFF); pārtraukums; 3. gadījums: while (! Serial.available ()); ja ((Serial.read ()) == 0xFF) {SNow = PosServoMax; kavēšanās (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; kavēšanās (500); Sērijas nospiedums (0); Sērijas nospiedums (4); Sērijas nospiedums (0xFF); } pārtraukums; }} cits if (rc == '2') {Serial.print ("Test Servo Motor / n"); while (! Serial.available ()); rc = Sērijas.lasījums (); if (rc == '1') {Serial.print ("1. režīms / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("2. režīms / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; kavēšanās (100); SNow = PosServoMin; kavēšanās (100); }

6. darbība: Interfaceamento Das Tecnologias

Paziņojumā Arduíno DUE ea DRAGONBOARD 410c, sākotnēji jāizmanto saskarne ar figūras acima, o que não foi possível executar, então optou-se pelo uso de uma interface USB CDC entre o Arduino DUE ea DRAG nepieciešamība pēc KERNEL da DRAGONBOARD 410c recompilação do, que não se fez por causa do curto tempo disponível.

7. darbība. Configuração Da DRAGONBOARD 410c (Python)

Arduino DUE konfigurācijas konfigurācija DUE os comandos para realizar a aquisição de dados and broadcastir os dados obtidos. Segue código abaixo.

Novērojums: 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. Ir arī optou-interfeiss ar USB, kas nepieciešams KERNEL un DRAGONBOARD 410c recompilação recompilação, lai iegūtu portatīvo portretu, kas ir koriģējošs komunicēšanai.

importēt laikuimportēt sērijveida importu pandas kā pd importēt numpy kā np

# Configuração da conexão sērija

ser = sērija. Sērija (ports = '/dev/ttyAMC0', #tty96B0 ', bitu pārraides ātrums = 250000, paritāte = sērija. PARITY_NONE, stopbiti = sērija. STOPBITS_ONE, baits = seriāls. EIGHTBITS)

ser.isOpen ()

drukāt ('Ievadiet savas komandas zemāk. / r / nLai izietu no lietojumprogrammas, ievietojiet "exit".')

ievade = 1

kamēr 1: ievade = ievade (">>"), ja ievade == 'izeja': 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 vai Arduino DUE raidītājs os dados coletados

saraksts =

i diapazonā (3000):

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

8. solis: INTERPRETAÇOO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez nepieciešamība un sarunvalodas arquivos no formāta WAV, fornecidos pelos alunos autores do TCC e colaboradores do projeto, para valores numéricos, que são utilizados nos algoritmos de anard 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. Lejupielādējiet algoritmu, kas ļauj to izmantot un lejupielādēt.

Esse algoritms não se faz nepiecieÅ¡amÄ «ba vai funkcionÄ lÄ s sistÄ“ma, jÅ «ka vai Arduino DUE jÄ enviara esses dados em um array de valores numéricos.

# kodēšana: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

importēt vilnis importēt numpy kā np importēt pandas kā pd importēt matplotlib.pyplot kā plt

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

def audio_to_csv (faila_nosaukums): 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) signāls = np.fromstring (waveData, dtype = 'int32') Laiks = np.linspace (sākums = 0, pietura = datu_izmērs/parauga_novērtējums, skaits = datu_izmērs, galapunkts = Patiess) df = pd.concat ([pd. DataFrame (signāls), pd. DataFrame (Time)], ass = 1) df.to_csv (faila_nosaukums + '.csv', indekss = False) atgriezt df

# CARREGANDO DATU RĀMTS COM OS DADOS DO AUDIO

file_name = 'Solo_com_Vazamento' df_vazamento = audio_to_csv (faila_nosaukums) df_vazamento.columns = ['amp', 'time'] file_name = 'Solo_sem_Vazamento' df_sem_vazamento = audio_to_csv (faila_nosaukums) df_sem_ávamz

# GRÁFICO DO ESPECTRO DE AUDIO

attēls, (ax1, ax2) = plt.subplots (nrows = 2, ncols = 1, figsize = (20, 10)) ax1.plot (df_vazamento ['laiks'], df_vazamento ['amp']) ax1.set_title ('Solo com Vazamento', fontdict = {'fontsize': 20, 'fontweight': 'bold'}) ax1.set_xlabel ('Temps [s]', fontdict = {'fontsize': 16}) ax1.set_ylim ([-4e8, 4e8]) ax2.plot (df_sem_vazamento ['laiks'], df_sem_vazamento ['amp']) ax2.set_title ('Solo sem Vazamento', fontdict = {'fontsize': 20, 'fontweight': 'bold' }) ax2.set_xlabel ('Temps [s]', fontdict = {'fontsize': 16}) ax2.set_ylim ([-4e8, 4e8]) skaitlis.timht_layout (h_pad = 5) plt.show ()

9. darbība. Visual Do Sinal analīze

Com PYTHON 3 realizē un pārveido Furjē, lai mākslīgi matemātiski realizētu un pārveidotu sinālu vai domināciju, lai veiktu dažu frekvenču ritmu, kā arī var izmantot torni, izmantojot analīzes kā dažādas frekvences, amplitūdas, kā arī dažādas akvarelis. Furjē pārveido grafisko grāfiju, lai pārveidotu profesionālās kompeciālās kompromisijas, un īpaši identificētu eksistenci, kas pastāv vazamento na tubulação. Estes gráficos servirão para validção das análises realizadas pelo algoritmo de detecção automática.

Ierobežots vai neregulārs frekvenču diapazons ir 100 Hz un 800 Hz, fica claro un eksistējoša vazamentos quando se observam distúrbios nesse range de frequências.

# kodēšana: utf-8# Metodikas utilizados for processamento da transformada de Fourier

importēt pandas kā pd importēt numpy kā np importa vilni no matplotlib importa pyplot kā plt# Função que realiza a transformation 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 [diapazons (n // 2)] Y = np.fft.fft (y)/n Y = Y [diapazons (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) att, ax = plt.subloti (2, 1, figsize = (20, 10)) ax [0].plode (t, y) ax [0].set_xlabel ('Laiks') ax [0].set_ylabel ('Amplitude') ax [1].plode (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 () atgriezties frq, abs (Y)# Função que realize a carga dos dados do CSV and chama a função de Fourier def read_csv (faila_nosaukums, init, galīgais): df = pd.read_csv (faila_nosaukums + '.csv') df.columns = ['amp', ' laiks '] delta = final-init, ja init*44100> len (df) vai final*44100> len (df): init = (len (df)/44100) -delta, ja init = 100) & (df [' freq '] <= 800)] mx = sakārtots (df [' amp ']) print ("Média das amplitude:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") print ("100 maiores amplitude", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplitūdas:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplitūdas:", 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) # Gráficos para vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Grāmatu paraugs

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

Izmantojiet algoritmu, lai realizētu procesu vai izmantotu papildu funkcijas (raksturīgās iezīmes).

Este primeiro algoritms realize uma extração identifada, onde ja é nepieciešamība 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á a extração não identifada, gerando somente as características sem uma identifação.

Estas funkcijas 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 algoritms faz parte de um projeto disponível no GitHub e pode ser acessado através deste link, o mesmo foi modificado para atender as espeacificações do projeto.

Izmantojiet bezmaksas programmatūru vai algoritmu, lejupielādējiet R e do R Studio interpretatoru.

Īpašas īpašības:

• meanfreq: vidējā frekvence (kHz)
• sd: frekvences standarta novirze
• mediāna: vidējā frekvence (kHz)
• 25. jautājums: pirmais kvantils (kHz)
• Q75: trešais kvantils (kHz)
• IQR: interkvantila diapazons (kHz)
• šķībs: šķība (sk. piezīmi specifiskā aprakstā)
• kurt: kurtosis (sk. piezīmi specifiskā aprakstā)
• sp.ent: spektrālā entropija
• sfm: spektra līdzenums
• režīms: režīma biežums
• centroid: frekvences centroid (skatīt specifikāciju)
• peakf: maksimālā frekvence (frekvence ar lielāko enerģiju)
• meanfun: pamata frekvences vidējais lielums, kas izmērīts akustiskajā signālā
• minfun: minimālā pamata frekvence, ko mēra akustiskajā signālā
• maxfun: maksimālā pamatfrekvence, ko mēra akustiskajā signālā
• meandoms: dominējošās frekvences vidējais lielums, kas mērīts akustiskajā signālā
• mindom: minimālā dominējošā frekvence, ko mēra akustiskajā signālā
• maxdom: dominējošās frekvences maksimums, ko mēra akustiskajā signālā
• dfrange: dominējošās frekvences diapazons, ko mēra akustiskajā signālā
• modindx: modulācijas indekss. Aprēķina kā uzkrāto absolūto starpību starp blakus esošo pamatfrekvenču mērījumiem, dalītu ar frekvenču diapazonu
• etiķete: noplūde vai bez noplūdes

Algoritmo:

iepakojumi <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'peles', 'e1071', 'rpart', 'xgboost', 'e1071'), ja (garums (setdiff (paketes, rownames (instalētas.paketes ())))> 0) {instalēt.paketes (setdiff (paketes, rownames (instalētās.paketes ())))})

bibliotēka (tuneR)

bibliotēka (seewave) bibliotēka (caTools) bibliotēka (rpart) bibliotēka (rpart.plot) bibliotēka (randomForest) bibliotēka (warbleR) bibliotēka (peles) bibliotēka (xgboost) bibliotēka (e1071)

specan3 <- funkcija (X, bp = c (0, 22), wl = 2048, slieksnis = 5, paralēla = 1) { # Lai izmantotu paralēlo apstrādi: bibliotēka (devtools), install_github ('nathanvan/parallelsugar'), ja (class (X) == "data.frame") {if (visi (c ("sound.files", "selec", "start", "end") % % % nosaukumos (X))) {start <- as.numeric (unlist (X $ start)) end <- as.numeric (unlist (X $ end)) sound.files <- as.character (unlist (X $ sound.files)) select <- as.character (unlist (X $ selec))} else stop (ielīmēt (ielīmēt (c ("sound.files", "selec", "start", "end")) [! (c ("sound.files", "selec", "sākums", "beigas") % % slejās (X))], sabrukums = ","), "kolonna (-as) nav atrasta datu rāmī"))} else stop ("X nav datu rāmis")) #ja sākuma vai beigu pieturā ir NA, ja (jebkurš (is.na (c (beigas, sākums))))) apstājas ("NA ir atrasts sākumā un/vai beigās") #ja beigas vai sākums nav skaitliska pietura if (viss (klase (beigas)! = "skaitlisks" & klase (sākums)! = "skaitlisks")) stop ("'end' un 'selec' jābūt skaitliskam") #ja jebkuram startam ir augstāka vērtība nekā beigu pieturai, ja (jebkura (beigas - sākums <0)) stop (paste ("Sākums ir augstāks par en d in ", garums (kas (beigas - sākums20)) stop (ielīmēt (garums (kas (beigas - sākums> 20)))," atlases (-es) ilgākas par 20 sekundēm ") iespējas (show.error.messages = TRUE) #ja bp nav vektors vai garums! = 2 pieturas, ja (! is.vector (bp)) stop ("" bp 'ir jābūt 2 garuma skaitliskam vektoram ") else {if (! length (bp) == 2) stop ("" bp "jābūt skaitliskam vektoram ar garumu 2")} #brīdinājums par atgriešanos, ja netika atrasti visi skaņas faili fs <- list.files (ceļš = getwd (), modelis = ".wav $", ignore.case = TRUE) if (length (unikāls (skaņu.files [(skaņu.fi % % % fs)]))! = garums (unikāls (skaņu.files))) kaķis (ielīmēt (garums (unikāls (skaņa). faili))-garums (unikāls (sound.files [(sound.files % % % fs)]))), ".wav fails (-i) nav atrasts")) #skaņu failu skaits darba direktorijā un ja 0 apstājas d <- kas (sound.files % % fs), ja (garums (d) == 0) {stop (".wav faili nav darba direktorijā")} cits {sākums <- sākums [d] beigas <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Ja paralēle nav skaitliska, ja (! ir.ciparu (paralēle)) stop (" būt skaitlisks vektors, kura garums ir 1 "), ja (jebkurš (! (paralēlais %% 1 == 0), paralēlais 1) {iespējas (brīdināt = -1), ja (viss (Sys.info () [1] ==" Windows ", needNamespace (" parallelsugar ", klusi = TRUE) == TRUE)) lapp <- funkcija (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = paralēle) else if (Sys.info () [1] == "Windows") {cat ("Windows lietotājiem paralēlajai skaitļošanai jāinstalē pakete" parallelsugar "(jūs to nedarāt!)") Lapp <- pbapply:: pblapply} else lapp <- funkcija (X, FUN) paralēli:: mclapply (X, FUN, mc.cores = paralēle)} else lapp <- pbapply:: pblapply options (brīdināt = 0) if (paralēli == 1) cat ("Akustisko parametru mērīšana:") x <- as.data.frame (lapp (1: garums (sākums), funkcija (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), no = sākums , līdz = beigas , vienības = "sekundes") b griesti ([email protected]/2000) - 1) b [2] < - griesti ([email protected]/2000) - 1 #frekvenču spektra analīze dziesmaspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analīze <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #saglabāt parametrus meanfreq <- analīze $ vidējais/1000 sd <- analīze $ sd/1000 mediāna <- analīze $ mediāna/1000 Q25 < - analīze $ QQ75 <- analīze $ QIQR <- analīze $ IQR/1000 šķībs <- analīze $ šķībums kurt <- analīze $ kurtosis sp.ent <- analīze $ sh sfm <- analīze $ sfm režīms <- analīze $ mode/1000 centroid <- analīze $ cent/1000 #Frekvence ar amplitūdas virsotnēm peakf <- 0 #seewave:: fpeaks (dziesmas, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Pamatfrekvences parametri ff <- seewave:: fund (r, f = [email protected], ovlp = 50, slieksnis = slieksnis, fmax = 280, ylim = c (0, 280/1000), grafiks = FALSE, wl = wl) [, 2] meanfun <-mean (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Dominējošie biežuma parametri y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, diagramma = F, slieksnis = slieksnis, joslas caurlaide = b * 1000, fftw = TRUE) [, 2] meandom <- vidējais (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) ilgums <- (beigas - sākums ) #modulācijas indeksa aprēķina izmaiņas <- vektors () priekš (j kurā (! ir. na (y))) {mainīt <- abs (y [j]- y [j + 1]) izmaiņas <- pievienot (izmaiņas, izmaiņas)} ja (mindom == maxdom) modindx <-0 cits modindx <- vidējais (izmaiņas, na.rm = T)/dfrange #save rezultāti atgriežas (c (ilgums, meanfreq, sd, mediana, Q25, Q75, IQR, šķībs, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #mainīt rezultātu nosaukumus rownames (x) <- c ("duration", "meanfreq", "sd", "median", "Q25", "Q75", "IQR", "šķībs", "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))) slejas nosaukumi (x) [1: 2] <- c ("sound.files", "selec") rownames (x) <- c (1: nrow (x)) return (x)}

processFolder <- funkcija (mapesNosaukums) { # Sāciet ar tukšiem datiem.rāmis. dati <- data.frame () # Iegūt mapē esošo failu sarakstu. list <- list.files (folderName, '\. wav') # Pievienojiet failu sarakstu data.frame apstrādei. for (fileName in list) {row <- data.frame (fileName, 0, 0, 20) data <- rbind (dati, rinda)} # Iestatīt kolonnu nosaukumus. vārdi (dati) <- c ('sound.files', 'selec', 'start', 'end') # Pārvietot uz mapi apstrādei. setwd (folderName) # Apstrādājiet failus. akustika <- specan3 (dati, paralēli = 1) # Pārvietot atpakaļ uz vecāku mapi. setwd ('..') akustika}

gender <- funkcija (filePath) {ja (! eksistē ('genderBoosted')) {load ('model.bin')} # Iestatīšanas ceļi. currentPath <- getwd () fileName <- basename (filePath) ceļš <- dirname (filePath) # Iestatiet direktoriju, lai lasītu failu. setwd (ceļš) # Sāciet ar tukšiem datiem.rāmis. dati <- data.frame (fileName, 0, 0, 20) # Iestatiet kolonnu nosaukumus. nosaukumi (dati) <- c ('sound.files', 'selec', 'start', 'end') # Apstrādāt failus. akustika <- specan3 (dati, paralēli = 1) # Atjaunot ceļu. setwd (currentPath) prognozēt (genderCombo, newdata = akustika)}

# Ielādēt datus

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

# Iestatiet etiķetes.

noplūde $ label <- 1 bez_ noplūdes $ etiķete <- 2 dati <- rbind (noplūde, bez_ noplūdes) dati $ label <- faktors (dati $ label, labels = c ('noplūde', 'bez noplūdes'))

# Noņemiet neizmantotās kolonnas.

dati $ ilgums <- NULL dati $ sound.files <- NULL dati $ selec <- NULL dati $ peakf <- NULL

# Noņemiet rindas, kurās ir NA.

dati <- dati [pilnīgi.lietas (dati),]

# Izrakstiet csv datu kopu.

write.csv (dati, fails = 'features.csv', sep = ',', row.names = F)

11. solis: Neural atjaunošana

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 model and treinado com dados previamente identifados and 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.

Nepieciešams realizēt uma filtragem dos dados de entrada, pois algumas características estavam diminuindo a taxa de acerto da rede ao invés de melhora-la. Não foi realizado nenhuma abordagem estatística muito aprofundada, mas mesmo com um trabalho mais superface pode-se chegar a algumas variáveis com bons desempenhos.

Para os sēklinieki realizācijas vai modeļa obteve um desempenho muito bom, alcançando na maioria dos sēklinieki uma taksometri de acerto de 100%, como pode ser observado with imagem anexa.

Este algoritms un utilizado para treinar o modelo da rede e retornar a taxa de acerto do mesmo. No sistēmas 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.

# kodēšana: utf-8

importēt pandas kā pd

importēt numpy kā np no sklearn.model_selection importēt train_test_split kā tts no sklearn.neural_network importēt MLPClassifier kā MLP no sklearn.metrics importēt klasifikācijas_ziņojumu kā kr no sklearn.metrics importēt confusion_matrix kā cm

# Leitura dos dados do CSV

df = pd.read_csv ('features.csv') ',' sd ',' Q25 ',' sfm ',' centroid ',' meandom ',' mindom '] # Separação das saidas df_Y = df [df.columns [-1] # Discretização das saidas df_Y = pd.get_dummies (df_Y) df_Y = df_Y ['noplūde']

# 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 neural

modelo = MLP (alfa = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, aktivizēšana = 'tanh', risinātājs = 'lbfgs')

# Treinando modelis

modelo.fit (X_train, Y_train) rezultāts = modelo.predict (X_test)

# Imprimindo resultados

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 Classificação") print (Ziņot)