Sistema Autônomo Localizador De Vazamentos: 11 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:41

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 identifierar 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 algoritmos installal 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), participaram do projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigues, Rogério. Gomes Polo och Ronaldo P. Gomes Polo. Também participou do projeto o aluno Daniel de Castro Pacheco graduando de engenharia mecânica vid Universidade Newton Paiva de Belo Horizonte. O projeto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro och Felipe Crispim da Silva Salvagnini.

Steg 1: Lista De Materiais

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

1 Arduino Due

1 Dragonboard 410c

2 drivrutiner för motor de corrente continua contendo cada um:

4 Transistorer BC548

4 Diodos 1n4007

4 Motstånd 4k7Ω ¼ W

1 drivrutin för servomotor:

1 Transistorer BC548

1 Diodos 1N4007

1 Motstår 4k7Ω ¼ W

1 USB -mus

1 Teclado USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engrenagem

1 servomotor 9g

Steg 2: Adaptação Mecânica

Para a aquisição dos dados pelo sensor piezoelétrico, faz se necessário, o desenvolvimento de um dispositivo com pinhão e cremalheira, conforme desenhos anexados, nästa caso as peças foram fabricadas por uma impressora 3D, devido ao fato de se tratar de um protto tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme vídeo.

Steg 3: Acionamento Dos Motores

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

Steg 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, mer detaljerade sobre o TCC e sobrev dispositiv mejla [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.

Som frekvens av intresse para o projeto estão entre 100Hz e 800Hz. Para isso o dispositivo de sensoriamento foi configurado com uma frequência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, onde a frequência de aquisição deve estar pelo menos duas vezes acima das frequênias

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

Steg 5: Configuração Do Arduino DUE (språk 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 analógica poder de processamento, isso foi needsário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine installed na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui poder de processamento para essa operação.

O Arduino DUE foi configurado para receber us comandos enviados da plataforma QUALCOMM DRAGONBOARD 410c via comunicação serial.

Som ações configuradas ingen Arduino foram:

Realizar a aquisição dos dados;

Transmitir os dados obtidos para a DRAGONBOARD 410c;

Segue a programação:

#inkluderar #definiera Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Period 60 osignerad int Scont = 0, SNow = PosServoMin; osignerad lång int DAC [Numb_Sample], ind = Numb_Sample; ogiltig TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); om (Scont

1); // 50% arbetscykel

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 [channel]. 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); // Init Timer // TC_Stop (TC1, 0); pinMode (SERVO, OUTPUT); }

void loop ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int index = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); switch (rc) {case 1: index = 0; medan (! Serial.available ()); medan ((rc = Serial.read ())! = 0xFF) {index << = 8; index += rc; medan (! Serial.available ()); } Serial.print (0); Serial.print (2); SendNumber (DAC [index]); Serial.print (0xFF); ha sönder; fall 3: medan (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; fördröjning (500); ind = 0; // TC_Start (TC1, 0); medan (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; fördröjning (500); Serial.print (0); Serial.print (4); Serial.print (0xFF); } ha sönder; }} annat ifall (rc == '2') {Serial.print ("Test Servomotor / n"); medan (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Läge 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Läge 2 / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; fördröjning (100); SNow = PosServoMin; fördröjning (100); }

Steg 6: Interfaceamento Das Tecnologias

Para 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 possicvel executor, então optou-se pelo uso de uma interface USB CDC entre o Arduino DUE ea DRAGONBOARD 410c, necessitaria da recompilação do KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

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

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

Obs: 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. För iso optou-se pelo interfaceaceamento USB, que needsitaria da recompilação do KERNEL na DRAGONBOARD 410c para que a porta fosse criada corretamente para a comunicação.

import timeimport seriell import pandor som pd import numpy som np

# Configuração da conexão serial

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

ser.isOpen ()

print ('Ange dina kommandon nedan. / r / nAnge "exit" för att lämna programmet.')

ingång = 1

medan 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 =

för i inom räckvidd (3000):

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

Steg 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez nødvendária a 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 algoritcos de análise. Para realizar esta conversão foi escrito um algoritmo em PYTHON 3 que lies or arquivo WAV e salva os dados do espectro em um arquivo CSV. O algoritmo utilizado segue abaixo e em anexo för nedladdning.

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

# kodning: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

import wave import numpy som np import pandor som pd import matplotlib.pyplot som plt

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

def audio_to_csv (filnamn): 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_size-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 (Time)], axel = 1) df.to_csv (filnamn + '.csv', index = falskt) returnerar df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

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

# GRÁFICO GÖR ESPECTRO DE AUDIO

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

Steg 9: Análise Visual Do Sinal

Com o PYTHON 3 é realizada a transformada de Fourier, este artificio matemático realiza a transformação do sinal do domínio do tempo para o domínio da frequência, onde se torna possível analisar as variias 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á identifierar 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.

Limitando o eixo das frequências entre 100Hz e 800Hz, fica claro a existência de vazamentos quando se observam distúrbios nesse range de frequências.

# kodning: utf-8# Användningsområden för processomvandling av Fourier

import pandor som pd import numpy som np import våg från matplotlib import pyplot som 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 tempos y = y ['amp'] # Vetor de amplitudes n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [intervall (n // 2)] Y = np.fft.fft (y)/n Y = Y [intervall (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) fig, ax = plt.subplots (2, 1, figsize = (20, 10)) ax [0]. plot (t, y) ax [0].set_xlabel ('Time') ax [0].set_ylabel ('Amplitude') ax [1]. Plot (frq, abs (Y), 'r') ax [1].set_xlim ([100, 800]) ax [1].set_ylim ([0, max_lim]) ax [1].set_xlabel ('Freq (Hz)') ax [1].set_ylabel ('| Y (freq) |') plt.show () return frq, abs (Y)# 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 (file_name + '.csv') df.columns = ['amp', ' time '] delta = final-init if init*44100> len (df) or final*44100> len (df): init = (len (df)/44100) -delta if init = 100) & (df [' freq '] <= 800)] mx = sorterat (df [' amp ']) print ("Média das amplitudes:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") print ("100 maiores amplitudes", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplituder:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplituder:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maior amplitud:", 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

Steg 10: Algoritmo Em R Para Extração Das Features 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 identifierada, onde é needsário saber se o arquivo de áudio trata-se de uma amostra vazamento detectado ou não, isso por que us dados resultantes desse processo servirão para o trainamento da rede neural utilizada.

Para quando o sistema estiver em modo de operação um algoritmo um pouco diferente será executado, onde não este fará a extração não identifierada, gerando somente as características sem uma identifieraçã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 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.

Om du använder programvara för att använda en algoritm för att ladda ner tolkningen av R e do R Studio.

Características extraídas:

• medelvärde: medelfrekvens (i kHz)
• sd: standardavvikelse för frekvens
• median: medianfrekvens (i kHz)
• Q25: första kvantil (i kHz)
• Q75: tredje kvantil (i kHz)
• IQR: interkvantilt intervall (i kHz)
• skevhet: skevhet (se anteckning i specprop -beskrivning)
• kurt: kurtosis (se anteckning i specprop beskrivning)
• sp.ent: spektral entropi
• sfm: spektral planhet
• läge: lägesfrekvens
• centroid: frekvens centroid (se specprop)
• peakf: toppfrekvens (frekvens med högsta energi)
• medelfunktion: medelvärdet av grundfrekvensen mätt över akustisk signal
• minfun: minsta grundfrekvens mätt över akustisk signal
• maxfun: maximal grundfrekvens mätt över akustisk signal
• meandom: medelvärdet av den dominerande frekvensen mätt över akustisk signal
• mindom: minsta dominanta frekvens mätt över akustisk signal
• maxdom: maximal dominansfrekvens mätt över akustisk signal
• dfrange: område av dominerande frekvens mätt över akustisk signal
• modindx: moduleringsindex. Beräknas som den ackumulerade absoluta skillnaden mellan intilliggande mätningar av grundfrekvenser dividerat med frekvensområdet
• etikett: läckage eller utan_läckage

Algoritmo usado:

paket <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'möss', 'e1071', 'rpart', 'xgboost', 'e1071') om (längd (setdiff (paket, rownames (installerat. paket ())))> 0) {install.packages (setdiff (paket, rownames (installed.packages ()))))}

bibliotek (tuneR)

bibliotek (seewave) bibliotek (caTools) bibliotek (rpart) bibliotek (rpart.plot) bibliotek (randomForest) bibliotek (warbleR) bibliotek (möss) bibliotek (xgboost) bibliotek (e1071)

specan3 <- funktion (X, bp = c (0, 22), wl = 2048, tröskel = 5, parallell = 1) { # För att använda parallell bearbetning: bibliotek (devtools), install_github ('nathanvan/parallelsugar') om (class (X) == "data.frame") {if (all (c ("sound.files", "selec", "start", "end") % in % 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))} stop annars (klistra in (klistra in (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "start", "slut") % i % kolumnnamn (X))], kollaps = ","), "kolumnerna finns inte i dataramen"))} stop annars ("X är inte en dataram") #om det finns NA i start- eller slutstopp om (något (is.na (c (slut, start)))) stopp ("NA hittas i start och/eller slut") #if slutet eller start är inte numeriskt stopp if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' and 'selec' must be numeric") #if any start higher than end stop if (any (end - start <0)) stop (paste ("Starten är högre än en d i ", längd (vilken (slut - start20)) stopp (klistra in (längd (vilken (slut - start> 20))," val (mer) längre än 20 sek ")) alternativ (show.error.messages = TRUE) #if bp är inte vektor eller längd! = 2 stopp om (! is.vektor (bp)) stopp ("'bp' måste vara en numerisk vektor med längd 2") annars {if (! length (bp) == 2) stop ("'bp' måste vara en numerisk vektor med längd 2")} #return-varning om inte alla ljudfiler hittades fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (length (unique (sound.files [(sound.files % in % fs)]))! = length (unique (sound.files))) cat (paste (length (unique (sound. filer))-längd (unik (sound.files [(sound.files % i % fs)])), ".wav-fil (er) hittades inte")) #antal ljudfiler i arbetskatalogen och om 0 slutar d <- vilken (sound.files % i % fs) if (length (d) == 0) {stop (".wav-filerna finns inte i arbetskatalogen")} else {start <- start [d] end <- slutet [d] selec <- selec [d] sound.files <- sound.files [d]} # Om parallell inte är numerisk om (! är. numeriskt (parallellt)) stopp ("'parallell' måste vara en numerisk vektor med längd 1 ") if (någon (! (parallell %% 1 == 0), parallell 1) {option (varna = -1) om (alla (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", tyst = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) else if (Sys.info () [1] == "Windows") {cat ("Windows-användare måste installera paketet 'parallelsugar' för parallell dator (du gör det inte nu!)") Lapp <- pbapply:: pblapply} else lapp <- funktion (X, FUN) parallell:: mclapply (X, FUN, mc.cores = parallel)} annars lapp <- pbapply:: pblapply alternativ (varna = 0) if (parallell == 1) cat ("Mätning av akustiska parametrar:") x <- as.data.frame (lapp (1: length (start), function (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), from = start , till = slut , enheter = "sekunder") b -tak ([email protected]/2000) - 1) b [2] < - tak ([email protected]/2000) - 1 #frekvensspektrumanalys songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analys <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #save parameters meanfreq <- analysis $ mean/1000 sd <- analysis $ sd/1000 median <- analysis $ median/1000 Q25 < - analys $ QQ75 <- analys $ QIQR <- analys $ IQR/1000 skev <- analys $ skevhet kurt <- analys $ kurtosis sp.ent <- analys $ sh sfm <- analys $ sfm läge <- analys $ mode/1000 centroid <- analys $ cent/1000 #Frekvens med amplitudtoppar peakf <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Grundläggande frekvensparametrar ff <- seewave:: fund (r, f = [email protected], ovlp = 50, tröskel = tröskel, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] medelvärde <-medel (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Dominerande frekvensparametrar y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, tröskel = tröskel, bandpass = b * 1000, fftw = TRUE) [, 2] meandom <- medelvärde (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) varaktighet <- (slut - start ) #modulationsindexberäkning ändras <- vektor () för (j där (! är. na (y))) {ändra <- abs (y [j]- y [j + 1]) ändrar <- lägg till (ändrar, ändra)} om (mindom == maxdom) modindx <-0 annars modindx <- medelvärde (ändringar, na.rm = T)/dfrange #save resultat return (c (varaktighet, medelvärde, sd, median, Q25, Q75, IQR, skev, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx)))))) ändra resultatnamn namn på namn (x) <- c ("varaktighet", "meanfreq", "sd", "median", "Q25", "Q75", "IQR", "skev", "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))) kolumnnamn (x) [1: 2] <- c ("sound.files", "selec") rownames (x) <- c (1: nrow (x)) return (x)}

processFolder <- function (folderName) { # Börja med tom data.frame. data <- data.frame () # Hämta lista över filer i mappen. list <- list.files (mappnamn, '\. wav') # Lägg till fillista i data.ram för bearbetning. för (filnamn i listan) {rad <- data.frame (filnamn, 0, 0, 20) data <- rbind (data, rad)} # Ange kolumnnamn. namn (data) <- c ('sound.files', 'selec', 'start', 'end') # Flytta till mapp för bearbetning. setwd (mappnamn) # Bearbeta filer. akustik <- specan3 (data, parallell = 1) # Flytta tillbaka till överordnad mapp. setwd ('..') akustik}

kön <- funktion (filePath) {om (! existerar ('genderBoosted')) {load ('model.bin')} # installationsvägar. currentPath <- getwd () fileName <- basename (filePath) sökväg <- dirname (filePath) # Ställ in katalog för att läsa fil. setwd (sökväg) # Börja med tom data.ram. data <- data.frame (filnamn, 0, 0, 20) # Ange kolumnnamn. namn (data) <- c ('sound.files', 'selec', 'start', 'end') # Bearbeta filer. akustik <- specan3 (data, parallell = 1) # Återställ sökväg. setwd (currentPath) förutsäga (genderCombo, newdata = akustik)}

# Ladda data

läckage <- processFolder ('caminho para o pasta com samples de áudio com vazamento') utan_läckage <- processFolder ('caminho para o pasta com samples de áudio sem vazamento')

# Ställ in etiketter.

läckage $ label <- 1 without_leakage $ label <- 2 data <- rbind (läckage, utan_läckage) data $ label <- faktor (data $ label, labels = c ('läckage', 'utan_läckage'))

# Ta bort oanvända kolumner.

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

# Ta bort rader som innehåller NA: er.

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

# Skriv ut csv -dataset.

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

Steg 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.

Ett nytt neuralt utnyttjande av MLP (Multilayer Perceptron), en modell som kan användas för att identifiera en modell eller en modell för att installera ett system för att identifiera en automatisk identifiering av sinal recebido.

Foi necessá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 ytlig 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á trainado da nuvem ou de alguma outra fonte e com esse modelo realizaria as prediçõeses for cada leitura realizada.

# kodning: utf-8

importera pandor som pd

importera numpy som np från sklearn.model_selection importera train_test_split som tts från sklearn.neural_network importera MLPClassifier som MLP från sklearn.metrics importklassificering_rapport som cr från sklearn.metrics importera confusion_matrix som cm

# Leitura dos dados do CSV

df = pd.read_csv ('features.csv') # Separação das entradas df_X = df [df.kolumner [: len (df.kolumner) -1] # Filtrando som 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 (alfa = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, aktivering = 'tanh', solver = 'lbfgs')

# Treinando modell

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

# Primindo resultat

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") tryck (Rapportera)