Sistema Autônomo Localizador De Vazamentos: 11 koraka

2024 Autor: John Day | [email protected]. Zadnja promjena: 2024-01-30 09:34

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

O processamento destes dados é realizado algoritam instalados na DRAGONBOARD 410c. Os dados também são enviados para um serviço na nuvem, responsável por auxiliar 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), učestvuju do projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rod. Gomes Polo e Ronaldo P. Gomes Polo. Também particiou do do projeto o aluno Daniel de Castro Pacheco graduando de 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 e Felipe Crispim da Silva Salvagnini.

Korak 1: Lista materijala

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

1 Arduino Due

1 Dragonboard 410c

2 vozača za motor de corrente continua contendo cada um:

4 tranzistora BC548

4 dioda 1n4007

4 Otpori 4k7Ω ¼ W

1 Upravljački program za servo motor:

1 Tranzistori BC548

1 dioda 1N4007

1 Otpori 4k7Ω ¼ W

1 USB miš

1 Teclado USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engrenagem

1 servo motor 9g

Korak 2: Adaptação Mecânica

Para a aquisição dos dados pelo sensor piezoelétrico, faz se neophodá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 trato de se tratar de pro trato de pro trato um protrao tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme vídeo.

Korak 3: Acionamento Dos Motores

Para executar a movimentação dos motores do robô ZUMO e do dispositivo de captura, fez-se neophodária a montagem 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.

Korak 4: 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 detalhes sobre o TCC dosos eso pod sos osospos do sosposos et pod sosos o téspos do sospos tósposos do técés sos o o técés dos vivo e -mail [email protected].

Este dispositivo utiliza-se de um sensor piezoelétrico e uma placa de circuito que realiza a filtragem e amplificação do sinal.

Kao frekvencije interesa za parametre projektora potrebno je unijeti 100Hz i 800Hz. Para isso o dispositivo de sensoriamento foi configurado com uma frekvenência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, onde a Freência de aquisição deve estar pelo menos duas vezes acima das frekvencias.

Aquisição é habilitada e desabilitada através da prekine do Arduino DUE.

Korak 5: Konfigurirajte Do Arduino DUE (jezik 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 needsários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada poder de processamento, isso foi neophodário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine instaliran na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui poder de processamento para essa operação.

O Arduino DUE za konfiguriranje parametara primatelja i kontrole za plataformu QUALCOMM DRAGONBOARD 410c putem comunicação serijskog.

Kao konfiguracija bez Arduino forama:

Realizar a aquisição dos dados;

Transmitir os dados obtidos para a DRAGONBOARD 410c;

Pregledajte program:

#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; nepotpisani dugi int DAC [Numb_Sample], ind = Numb_Sample; void TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); ako (Scont

1); // 50% radni ciklus

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}

void setup ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Pokretanje mjerača vremena // TC_Stop (TC1, 0); pinMode (SERVO, OUTPUT); }

void loop ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int indeks = 0; if (rc == 0) {while (! Serial.available ()); rc = Serijski.čitaj (); switch (rc) {slučaj 1: indeks = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indeks << = 8; indeks += rc; while (! Serial.available ()); } Serial.print (0); Serijski.ispis (2); SendNumber (DAC [indeks]); Serijski.ispis (0xFF); pauza; slučaj 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; kašnjenje (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; kašnjenje (500); Serijski.ispis (0); Serijski.ispis (4); Serijski.ispis (0xFF); } pauza; }} else if (rc == '2') {Serial.print ("Testiraj servo motor / n"); while (! Serial.available ()); rc = Serijski.čitaj (); if (rc == '1') {Serial.print ("Način 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Način 2 / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; kašnjenje (100); SNow = PosServoMin; kašnjenje (100); }

Korak 6: Interfaceamento Das Tecnologias

Za zajedničko korištenje dosadašnjeg ulaza o Arduínu DUE ea DRAGONBOARD 410c, inicijalno koristite sučelje za figura acima, o que não foi possível izvršni program, opto-optou-se pelo uso de uma sučelje USB CDC ulaz o Arduino DUE ea DRAGONBOARD10, needitaria da recompilação do KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

Korak 7: Konfigurirajte DRAGONBOARD 410c (Python)

Foi konfiguracija para enviar ao Arduino DUE os comandos para realizar a aquisição de dados e transmitir os dados obtidos. Segue código abaixo.

Opservação: 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 incompatíveis. Ako želite uključiti USB sučelje, potrebno je ponovno sastavljanje KERNEL-a na DRAGONBOARD 410c za prijenos poruka o križanju ispravno za komunikaciju.

import timeimport serijski import pandas kao pd import numpy kao np

# Konfigurirajte da conexão serijski

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

ser.isOpen ()

print ('Unesite svoje naredbe ispod. / r / nUmetnite "exit" za napuštanje aplikacije.')

ulaz = 1

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

lista =

za ja u rasponu (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)

Korak 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez needária a razgovaão dos arquivos no format WAV, fornecidos pelos alunos autores do TCC e colaboradores do projeto, para valores numéricos, que são utilizadosOd 4 algoritam DROG. Para realizar esta converão foi escrito um algoritmo em PYTHON 3 que lê o arquivo WAV e salva os dados do espectro em um arquivo CSV. O algoritmu utilizado segue abaixo e em anexo para download.

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

# kodiranje: utf-8

# Leitura e razgovaão dos audios para csv

# MÓDULOS UTILIZADOS

import wave import numpy kao np import pandas kao pd import matplotlib.pyplot kao plt

# FUNÇÃO PARA KONVERTOR 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.readframe 1) 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 (vrijeme)], os = 1) df.to_csv (naziv_datoteke + '.csv', indeks = lažno) return df

# OKVIR PODATAKA CARREGANDO COM OS DADOS DO AUDIO

file_name = 'Solo_com_Vazamento' df_vazamento = audio_to_csv (naziv_datoteke) df_vazamento.columns = ['amp', 'vrijeme'] ime_datoteke = 'Solo_sem_Vazamento' df_sem_vazamento = audio_to_csv (naziv_datoteke) [df_sem_vans]

# GRÁFICO DO ESPECTRO DE AUDIO

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

Korak 9: Analiza vizualnog učinka Sinal

Com o PYTHON 3 je realizirao transformaciju de Fouriera, este artificio matemático je ostvario transformaciju do sinal do dominio do tempa para o domínio da frekvención, onde se torna possível analisar as varias frekvencije, e suas amplitude, que compõem aquele sinal. Pela análise visual do gráfico da transformira de Fourier um profissional com conhecimentos específicos poderá identificar a existência de algum vazamento na tubulação. Estes gráficos servirão para validação das análises realizadas pelo algoritmo de detecção automática.

Ograničeno na eixo das frekvencije entre 100Hz i 800Hz, fica claro a postojeência de vazamentos quando se promatraju distúrbios nesse range de Freências.

# coding: utf-8# Moodlos utilizados para processamento da transformira de Fouriera

import pandas as pd import numpy as np import wave from matplotlib import pyplot as plt# Função que realization a transformacija 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 tempos y = y ['amp'] # Vetor de amplitude n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [raspon (n // 2)] Y = np.fft.fft (y)/n Y = Y [raspon (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 ('Vrijeme') 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 realization a carga dos dados do CSV e chama a função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (file_name + '.csv') df.columns = ['amp', ' vrijeme '] delta = final-init ako je init*44100> len (df) ili final*44100> len (df): init = (len (df)/44100) -delta ako je init = 100) & (df [' freq '] <= 800)] mx = sortirano (df [' amp ']) print ("Média das amplitude:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitude.") print ("100 maiores amplitude", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplitude:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplituda:", 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) # Exemplo de gráficos para vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Exemplo de gráficos para sem vazamento

Korak 10: Algoritmo Em R Para Extração Das Značajke 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 identificada, onde é neophodário sabre 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 sistemu estiver em modo de operação um algoritmo um pouco diferente será executado, onde não este fará a extração não identificada, gerando somente as características sem uma identificação.

Estas features ou caraterísticas são propriedades acústicas compostas por varias informações referentes ao espectro de áudio capturado, abaixo seguirá uma descriptionçã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 softverskom korisniku za rodar ili algoritmu é gratuito, preuzmite za tumačenje R e do R Studio.

Dodatne značajke:

• meanfreq: srednja frekvencija (u kHz)
• sd: standardna devijacija frekvencije
• medijana: srednja frekvencija (u kHz)
• Q25: prvi kvantil (u kHz)
• Q75: treći kvantil (u kHz)
• IQR: interkvantilni raspon (u kHz)
• iskrivljenost: iskrivljenost (vidi napomenu u opisu specifikacije)
• kurt: kurtosis (vidi napomenu u opisu specifikacije)
• sp.ent: spektralna entropija
• sfm: spektralna ravnost
• mode: frekvencija moda
• centroid: frekvencijski centroid (vidi specifikaciju)
• peakf: vršna frekvencija (frekvencija s najvećom energijom)
• meanfun: prosjek osnovne frekvencije izmjeren preko zvučnog signala
• minfun: minimalna osnovna frekvencija izmjerena preko zvučnog signala
• maxfun: najveća osnovna frekvencija izmjerena preko zvučnog signala
• meandom: prosjek dominantne frekvencije izmjeren preko zvučnog signala
• mindom: minimum dominantne frekvencije izmjeren preko zvučnog signala
• maxdom: maksimum dominantne frekvencije izmjeren preko zvučnog signala
• dfrange: raspon dominantne frekvencije izmjeren preko zvučnog signala
• modindx: indeks modulacije. Izračunato kao akumulirana apsolutna razlika između susjednih mjerenja osnovnih frekvencija podijeljena s frekvencijskim rasponom
• oznaka: curenje ili bez_puštanja

Algoritmo usado:

paketi <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'miševi', 'e1071', 'rpart', 'xgboost', 'e1071') ako (dužina (setdiff (paketi, nazivi redova (instal.packages ())))> 0) {install.packages (setdiff (paketi, nazivi redova (instal.packages ())))}}

knjižnica (tuneR)

library (seewave) library (caTools) library (rpart) library (rpart.plot) library (randomForest) library (warbleR) library (miševi) library (xgboost) knjižnica (e1071)

specan3 <- funkcija (X, bp = c (0, 22), wl = 2048, prag = 5, paralelno = 1) { # Za korištenje paralelne obrade: knjižnica (devtools), install_github ('nathanvan/parallelsugar') ako (class (X) == "data.frame") {if (all (c ("sound.files", "selec", "start", "end") % u % colnames (X))) {start <- as.numeric (unlist (X $ start)) end <- as.numeric (unlist (X $ end)) sound.files <- as.character (unlist (X $ sound.files)) selec <- as.character (unlist (X $ selec))} else stop (paste (paste (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "start", "end") % u % colnames (X))], kolaps = ","), "stupac (i) nisu pronađeni u okviru podataka"))} else stop ("X nije okvir podataka") #ako postoje NA u početnom ili završnom zaustavljanju ako (bilo koja (is.na (c (kraj, početak))))) zaustavi ("NA se nalaze u početku i/ili kraju") #ako kraj ili početak nisu numeričko zaustavljanje if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' i 'selec' moraju biti numerički") #ako bilo koji početak veći od end stop ako (any (end - start <0)) stop (paste ("Početak je veći od en d u ", duljina (koja (kraj - početak20)) zaustavi (zalijepi (duljina (koja (kraj - početak> 20))," odabir (i) dulji od 20 sekundi ")) opcije (show.error.messages = TRUE) #ako bp nije vektor ili duljina! = 2 stop if (! is.vector (bp)) stop ("'bp' mora biti numerički vektor duljine 2") else {if (! length (bp) == 2) stop ("'bp' mora biti numerički vektor duljine 2")} #return warning ako nisu pronađene sve zvučne datoteke fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (length (jedinstven (zvučni.fajlovi [(zvučni.fajlovi % u % fs)]))! = duljina (jedinstveni (zvučni.datoteke))) cat (paste (duljina (jedinstven (zvuk. datoteke))-duljina (jedinstvena (zvučne datoteke [(zvučne datoteke % u % fs)]))), ".wav datoteke nije pronađena")) #broj zvučnih datoteka u radnom direktoriju i ako se 0 zaustavi d <- which (sound.files % in % fs) if (length (d) == 0) {stop ("Datoteke.wav nisu u radnom direktoriju")} else {start <- start [d] end <- kraj [d] odabir <- odabir [d] zvuk.datoteke <- zvuk.datoteke [d]} # Ako paralela nije numerička ako se (! is.broj (paralelno)) zaustavi ("" paralelna "mora biti numerički vektor duljine 1 ") if (bilo koji (! (paralelni %% 1 == 0), paralelni 1) {opcije (upozori = -1) if (sve (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", tiho = TRUE) == TRUE)) lapp <- funkcija (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = paralelno) else if (Sys.info () [1] == "Windows") {cat ("Korisnici sustava Windows moraju instalirati paket 'parallelsugar' za paralelno računanje (to sada ne radite!)") Lapp <- pbapply:: pblapply} else lapp <- funkcija (X, FUN) paralelno:: mclapply (X, FUN, mc.cores = paralelno)} else lapp <- pbapply:: pblapply opcije (upozorenje = 0) if (paralelno == 1) cat ("Mjerenje akustičkih parametara:") x <- as.data.frame (lapp (1: length (start), function (i)) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), from = početak , do = kraj , jedinice = "sekunde") b strop ([email protected]/2000) - 1) b [2] < - strop ([email protected]/2000) - 1 #analiza frekvencijskog spektra songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analiza <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #spremi parametre meanfreq <- analiza $ prosjek/1000 sd <- analiza $ sd/1000 medijana <- analiza $ medijana/1000 Q25 < - analiza $ QQ75 <- analiza $ QIQR <- analiza $ IQR/1000 skew <- analiza $ skewness kurt <- analiza $ kurtosis sp.ent <- analiza $ sh sfm <- analiza $ sfm način <- analiza $ način/1000 centroid <- analiza $ cent/1000 #Frekvencija s vrhovima amplitude peakf <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Temeljni parametri frekvencije ff <- seewave:: fund (r, f = [email protected], ovlp = 50, prag = prag, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] meanfun <-sredstvo (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Dominantni parametri frekvencije y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, prag = prag, propusni opseg = b * 1000, fftw = TRUE) [, 2] meandom <- prosjek (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) duration <- (end - start ) #izračun indeksa modulacije se mijenja <- vector () za (j u kojem (! je. na (y))) {change <- abs (y [j]- y [j + 1]) changes <- dodaj (promijeni, promijeni)} if (mindom == maxdom) modindx <-0 else modindx <- znači (promjene, na.rm = T)/dfrange #save rezultati se vraćaju (c (trajanje, srednja frekvencija, sd, medijana, Q25, Q75, IQR, iskrivljenje, kurt, sp.ent, sfm, način rada, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #promijeni nazive rezultata imena redaka (x) <- c ("trajanje", "meanfreq", "sd", "medijana", "Q25", "Q75", "IQR", "kos", "kurt", "sp.ent", "sfm", "način rada", "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") imena redaka (x) <- c (1: nrow (x)) return (x)}

processFolder <- function (folderName) { # Počnite s praznim data.frame. data <- data.frame () # Preuzmite popis datoteka u mapi. list <- list.files (folderName, '\. wav') # Dodaj popis datoteka u data.frame za obradu. za (naziv datoteke na popisu) {redak <- data.frame (naziv datoteke, 0, 0, 20) podatak <- rbind (podaci, redak)} # Postavite nazive stupaca. names (data) <- c ('sound.files', 'selec', 'start', 'end') # Premjesti u mapu radi obrade. setwd (folderName) # Obradi datoteke. akustika <- specan3 (podaci, paralelno = 1) # Vrati se natrag u nadređenu mapu. setwd ('..') akustika}

spol <- funkcija (filePath) {if (! postoji ('genderBoosted')) {load ('model.bin')} # Putovi postavljanja. currentPath <- getwd () fileName <- basename (filePath) path <- dirname (filePath) # Postavi direktorij za čitanje datoteke. setwd (path) # Počnite s praznim podacima.frame. data <- data.frame (fileName, 0, 0, 20) # Postavite nazive stupaca. names (data) <- c ('sound.files', 'selec', 'start', 'end') # Obradi datoteke. akustika <- specan3 (podaci, paralela = 1) # Vrati put. setwd (currentPath) predviđanje (genderCombo, newdata = akustika)}

# Učitaj podatke

curenje <- processFolder ('caminho para o tjestenina com uzorci de áudio com vazamento') without_leakage <- processFolder ('caminho para o tjestenina com uzorci de áudio sem vazamento')

# Postavite oznake.

curenje $ label <- 1 without_leakage $ label <- 2 data <- rbind (leakage, without_leakage) data $ label <- faktor (data $ label, labels = c ('curenje', 'bez_leakage'))

# Uklonite neiskorištene stupce.

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

# Uklonite retke koji sadrže NA.

podaci <- podaci [potpuni.slučajevi (podaci),]

# Ispišite csv skup podataka.

write.csv (data, file = 'features.csv', sep = ',', row.names = F)

Korak 11: Iskoristite neuronsko

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

Rede neural utilizada é do tipo MLP (Multilayer Perceptron), este modelo é treinado com dados previamente identificados e após esse treinamento o modelo implantado no system conseguirá realizar a identificação automática do sinal receido, informando se naquele ponto existe

Foi needá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 mais površno pode-se chegar 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 taxa de acerto de 100%, como pode ser observado na imagem anexa.

Este algoritmo é utilizado para treinar o modelo da rede e 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.

# kodiranje: utf-8

uvoz pandi kao pd

uvoz numpy kao np iz sklearn.model_selection uvoz train_test_split kao tts iz sklearn.neural_network uvoz MLPClassifier kao MLP iz sklearn.metrics uvoz classic_report kao cr iz sklearn.metrics uvoz confusion_matrix kao cm

# Dopunske informacije o CSV -u

df = pd.read_csv ('features.csv') # Odvojite das entradas df_X = df [df.columns [: len (df.columns) -1] # Filtrando kao 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 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) rezultat = modelo.predict (X_test)

# Imprimindo rezultati

izvještaj = cr (Y_test, rezultat) mat = cm (y_pred = rezultat, y_true = Y_test) ispis ("Matriz de confusão") ispis (mat, kraj = "\ n / n") ispis ("Relatório de Classificação") ispis (izvješće)