Sistema Autonomo Localizador De Vazamentos: 11 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Questo progetto consiste in un robô, in quanto è realizzato da leitura per un dispositivo, equipaggiato con un sensore piezoelettrico, captura os espectros das vibrações no solo, pode identificator e localizzare, com o processamento dos dados por uma rede neural, possíveis vazamentos de águazamentos uma tubulação.

O processamento destes dados é realizzato per algoritmi installati na DRAGONBOARD 410c. Tutti i dati possono essere utilizzati per qualsiasi servizio, non è responsabile di alcun processo di integrità artificiale del progetto.

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 Ap. Gomes Polo e Ronaldo P. Gomes Polo. Também participou 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.

Fase 1: Lista De Materiais

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

1 Arduino Due

1 Dragonboard 410c

2 Driver per motore de corrente continua contendo cada um:

4 transistor BC548

4 Diodi 1n4007

4 resistori 4k7Ω ¼ W

1 Driver per servomotore contendo:

1 Transistor BC548

1 Diodo 1N4007

1 Resistenze 4k7Ω ¼ W

1 mouse USB

1 Teclado USB

1 monitor

1 cavo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engrenagem

1 Servomotore 9g

Fase 2: Adattamento meccanico

Per aquisição dos dados pelo sensor piezoelétrico, faz se necessário, o desenvolvimento de um device com pinhão and cremalheira, conformati desenhos anexados, neste case as peças foram fabricadas por uma impressora 3D, devido ao fato de se tratar de um protótipo e aa tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizzando fita dupla face, conforme vídeo.

Fase 3: Acionamento Dos Motores

Per eseguire la movimentazione dei motori del robô ZUMO e del dispositivo di cattura, se necessario per il montaggio dei driver per i motori di corrente continua e um driver per o servo motor, conforme as figuras acima, sendo a primeira figura o driver para um motore de corrente continua ea seconda o driver para um servomotore.

Passaggio 4: Obtenção Do Áudio

Per ottenere lo spettro dell'audio delle vibrazioni da solo, per utilizzare il dispositivo in evoluzione come parte di TCC di Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro e Felipe C. da Silva Salvagnini, maggiori dettagli su TCC e su solista o dispositivo di comando 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.

Come frequenze di interesse per il progetto estão tra 100Hz e 800Hz. Per quanto riguarda il dispositivo di sensoriamento per essere configurato con una frequenza di acquisizione di 3 kHz per quanto riguarda la risposta come condições do teorema de amostragem de Nyquist, onde una frequenza di acquisizione deve estar meno due volte acima das frequências estudada

Un'acquisizione è abilitata e disabilitata attraverso l'interruzione di Arduino DUE.

Passaggio 5: configurazione di Arduino DUE (linguagem C)

Devido a grande quantidade de dados, cerca de 3000 pontos por segundo, do tipo inteiro de 32 bits, gerados pelo device de sensoriamento e necessários para processamento dos algoritmis na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada analógica com maior il processore è necessario per lo Shield di interfacciamento Grove Seeed Sensor Mezzanine installato su DRAGONBOARD 410c, che dispone del microcontrollore ATmega 328, non è possibile eseguire il processo per l'operazione.

O Arduino DUE per la configurazione del ricevitore os comandi in prossimità della piattaforma QUALCOMM DRAGONBOARD 410c tramite comunicazione seriale.

Come ações configuradas no Arduino foram:

Realizzare un'acquisizione dei dati;

Trasmetti i dati necessari per una DRAGONBOARD 410c;

Segue a programação:

#include#define Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Periodo 60 unsigned int Scont=0, SNow=PosServoMin; unsigned long int DAC[Numb_Sample], ind=Numb_Sample; void TC3_Handler() { TC_GetStatus(TC1, 0); if (ind < Numb_Sample) DAC[ind++] = analogRead(DAC_Input); if(Scont

1); // 50% ciclo di lavoro

TC_SetRC(tc, canale, rc); TC_Start(tc, canale); tc->TC_CHANNEL[canale]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // abilita os registradores tc->TC_CHANNEL[channel]. TC_IDR = ~(TC_IER_CPCS | TC_IER_CPAS); // disabilita i registratori NVIC_EnableIRQ(irq); // abilitazione interruzione }

configurazione nulla ()

{ Serial.begin(115200); pinMode(DAC_Input, INPUT); TimerStart(TC1, 0, TC3_IRQn, 1500);//Inizia il timer //TC_Stop(TC1, 0); pinMode(SERVO, USCITA); }

ciclo vuoto()

{ /*//while(!Serial.available()); char rc;//=Serial.read(); indice int = 0; if(rc==0) { while(!Serial.available()); rc=Serial.read(); switch(rc) { caso 1: indice=0; while(!Serial.available()); while((rc=Serial.read())!=0xFF) { indice <<= 8; indice += rc; while(!Serial.available()); } Serial.print(0); Stampa.seriale(2); InviaNumero(DAC[indice]); Serial.print(0xFF); rottura; caso 3: while(!Serial.available()); if((Serial.read())==0xFF) { SNow=PosServoMax; ritardo (500); ind=0; //TC_Start(TC1, 0); while(ind<Numb_Sample); //TC_Stop(TC1, 0); NEVE=PosServoMin; ritardo (500); Serial.print(0); Serial.print(4); Serial.print(0xFF); } rottura; } } else if(rc=='2') { Serial.print("Test Servomotore\n"); while(!Serial.available()); rc=Serial.read(); if(rc=='1') { Serial.print("Modo 1\n"); NEVE=PosServoMax; } if(rc=='2') { Serial.print("Modo 2\n"); NEVE=PosServoMin; } } */ SNow=PosServoMax; ritardo(100); NEVE=PosServoMin; ritardo(100); }

Step 6: Interfacciamento Das Tecnologias

Per comunicação dos dados entre o Arduíno DUE ea DRAGONBOARD 410c, inizialmente utilizou-se a interface da figura acima, o que não foi possível executar, então optou-se pelo us de uma interface USB CDC entre o Arduino DUE ea DRAGONBOARD 410c, 410c, necessitaria da recompilação do KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

Passaggio 7: configurazione della DRAGONBOARD 410c (Python)

È possibile configurare per l'ambiente come Arduino DUE os comandi per realizzare un'acquisizione di dati e trasmettere i dati necessari. Segue codice abaixo.

Osservazione: un 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. Per quanto riguarda l'interfacciamento USB, è necessario che sia necessario ricompilare KERNEL na DRAGONBOARD 410c per una porta che sia correttamente impostata per una comunicazione.

import timeimport serial import panda as pd import numpy as np

# Configurazione della connessione seriale

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

ser.isOpen()

print('Inserisci i tuoi comandi qui sotto.\r\nInserisci "exit" per uscire dall'applicazione.')

ingresso=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 trasmettitore DUE os dados coletados

lista =

per i nell'intervallo (3000):

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

Passaggio 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez necessá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 que s i s drazados nos algoritmo 410. Para realizar esta conversão foi escrito um algoritmo em PYTHON 3 que lê o arquivo WAV e salva os dados do espectro em um arquivo CSV. O algoritmo utilizado segue abaixo e em anexo para download.

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.

# codifica: utf-8

# Leitura e conversazione di audio per csv

# MÓDULOS UTILIZZATI

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

# FUNÇÃO PARA CONVERTER 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.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(segnale), pd. DataFrame(Time)], axis=1) df.to_csv(file_name + '.csv', index=False) return df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

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

# GRFICO 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()

Passaggio 9: Analizzare 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 varias frequências, e suas amplitudes, que compõem aquele sinal. Pela análise visual do gráfico da transformada de Fourier um profissional com conhecimentos específicos poderá 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.

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.

# coding: utf-8# Moduli utilizados per processamento da transformada de Fourier

import pandas as pd import numpy as np import wave from matplotlib import pyplot as plt# Funzione per realizzare una trasformazione di Fourier e tracciare grafici per analizzare def Fourier(df_list): Fs = 44100; # Taxa de astragem em Hz Ts = 1.0/Fs; # Intervallo di astragem y = pd.concat(df_list) t = y['time'] # Vetor de tempi y = y['amp'] # Vetor de amplitudes n = len(y) # Comprimento do sinal k = np. arange(n) T = n/Fs frq = k/T frq = frq[range(n//2)] Y = np.fft.fft(y)/n Y = Y[range(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 dodos 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', ' time'] delta = final-init se init*44100 > len(df) o final*44100 > len(df): init = (len(df)/44100)-delta se init =100) & (df['freq ']<=800)] mx = sorted(df['amp']) print("Media delle ampiezze:", np.round(np.mean(mx))) print("Percentuale di relazioni sulla media delle ampiezze.") print("100 maggiori ampiezze ", np.mean(mx[-100:])//df['amp'].mean()*100, "%", sep="") print("50 ampiezze maggiori:", np.mean(mx[-50:])//df ['amp'].mean()*100, "%", sep="") print("10 ampiezze maggiori:", np.mean(mx[-10:])//df['amp']. mean()*100, "%", sep="") print("Ampiezza maggiore:", np.mean(mx[-1:])//df['amp'].mean()*100, " %", sep="")read_csv('Solo_com_Vazamento', 2, 10) # Esempio di grafica per vazamentoread_csv('Solo_sem_Vazamento', 2, 10) # Esempio di grafica per sem vazamento

Passaggio 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 identificada, onde é necessário saber se o arquivo de áudio trata-se de uma amostra vazamento detectado ou não, isso por que os dados risultanti desse process servirão para o treinamento da rede neural utilizada.

Para quando o sistema estivor em modo de operação um algoritmo um pouco diferente será executado, onde não este fará a extração não identificatoda, gerando somente as características sem uma identificação.

Le caratteristiche sono le caratteristiche o le caratteristiche acustiche compostate per varie informazioni referenti e lo spettro dell'audio catturato, seguirá la descrizione (in inglese) delle caratteristiche.

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 software usado para rodar o algoritmo é gratuito, download do interpretador R e do R Studio.

Caratteristiche extra:

• meanfreq: frequenza media (in kHz)
• sd: deviazione standard della frequenza
• mediana: frequenza mediana (in kHz)
• Q25: primo quantile (in kHz)
• Q75: terzo quantile (in kHz)
• IQR: intervallo interquantile (in kHz)
• skew: skewness (vedi nota nella descrizione dello specprop)
• kurt: kurtosis (vedi nota nella descrizione di specprop)
• sp.ent: entropia spettrale
• sfm: planarità spettrale
• modalità: modalità frequenza
• centroide: centroide di frequenza (vedi specprop)
• peakf: frequenza di picco (frequenza con la massima energia)
• meanfun: media della frequenza fondamentale misurata attraverso il segnale acustico
• minfun: frequenza fondamentale minima misurata attraverso il segnale acustico
• maxfun: frequenza fondamentale massima misurata attraverso il segnale acustico
• meandom: media della frequenza dominante misurata attraverso il segnale acustico
• mindom: minimo della frequenza dominante misurata attraverso il segnale acustico
• maxdom: massimo della frequenza dominante misurata attraverso il segnale acustico
• dfrange: gamma di frequenza dominante misurata attraverso il segnale acustico
• modindx: indice di modulazione. Calcolato come differenza assoluta accumulata tra misurazioni adiacenti di frequenze fondamentali divisa per l'intervallo di frequenza
• etichetta: perdite o senza_perdite

Algoritmo usato:

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

libreria (sintonizzatore)

libreria (seewave) libreria (caTools) libreria (rpart) libreria (rpart.plot) libreria (randomForest) libreria (warbleR) libreria (mice) libreria (xgboost) libreria (e1071)

specan3 <- function(X, bp = c(0, 22), wl = 2048, soglia = 5, parallel = 1){ # Per usare l'elaborazione parallela: library(devtools), install_github('nathanvan/parallelsugar') if(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)) select <- as.character(unlist(X$selec)) } else stop(paste(paste(c("sound.files", "selec", "start", "end")[!(c("sound.files", "selec", "start", "end") %in% colnames(X))], collect=", "), "colonna(e) non trovata nel frame di dati")) } else stop("X non è un frame di dati") #if ci sono NA in start o end stop if(any(is.na(c(end, start)))) stop("NAs trovati in start e/o end") #if end o start non sono numerici stop if(all(class(end) != "numeric" & class(start) != "numeric")) stop("'end' e 'selec' devono essere numerici") #if any start superiore a end stop if(any(end - start<0)) stop(paste("L'inizio è maggiore di en d in", length(which(end - start20)) stop(paste(length(which(end - start>20)), "selection(s) più lungo di 20 sec")) options(show.error.messages = TRUE) #if bp non è vettore o lunghezza!=2 stop if(!is.vector(bp)) stop("'bp' deve essere un vettore numerico di lunghezza 2") else{ if(!length(bp) == 2) stop("'bp' deve essere un vettore numerico di lunghezza 2")} #return avviso se non sono stati trovati tutti i file audio 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.files))) files))-length(unique(sound.files[(sound.files %in% fs)])), ".wav file(s) not found")) #count number of sound files in working directory and if 0 stop d <- which(sound.files %in% fs) if(length(d) == 0){ stop("I file.wav non sono nella directory di lavoro") } else { start <- start[d] end <- end[d] selec <- selec[d] sound.files <- sound.files[d] } # Se parallel non è numerico if(!is.numeric(parallel)) stop("'parallel' must essere un vettore numerico di lunghezza 1") if(any(!(parallel %% 1 == 0), parallel 1) { options(warn = -1) if(all(Sys.info()[1] == " Windows", requireNamespace("parallelsugar", quietly = TRUE) == TRUE)) lapp <- function(X, FUN) parallelsugar::mclapply(X, FUN, mc.cores = parallel) else if(Sys.info() [1] == "Windows"){ cat("Gli utenti Windows devono installare il pacchetto 'parallelsugar' per il calcolo parallelo (non lo stai facendo ora!)") lapp <- pbapply::pblapply} else lapp <- function (X, FUN) parallel::mclapply(X, FUN, mc.cores = parallel)} else lapp <- pbapply::pblapply options(warn = 0) if(parallel == 1) cat("Misurazione dei parametri acustici:") x <- as.data.frame(lapp(1:length(start), function(i) { r <- tuneR::readWave(file.path(getwd(), sound.files), from = inizio, to = fine, unità = "secondi") b soffitto([email protected]/2000) - 1) b[2] <- soffitto([email protected]/2000) - 1 #analisi dello spettro di frequenza songpec <- seewave::spec(r, f = [email protected], plot = FALSE) analisi <- seewave::specprop(songspec, f = [email protected], flim = c(0, 280/1000), plot = FALSE) #salva parametri mediafreq <- analisi$media/1000 sd <- analisi$sd/1000 mediana <- analisi$mediana/1000 Q25 < - analysis$QQ75 <- analysis$QIQR <- analysis$IQR/1000 skew <- analysis$skewness kurt <- analysis$kurtosis sp.ent <- analysis$sh sfm <- analysis$sfm mode <- analysis$mode/1000 centroid <- analysis$cent/1000 #Frequenza con picchi di ampiezza peakf <- 0#seewave::fpeaks(songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE)[1, 1] #Parametri di frequenza fondamentali ff <- seewave::fund(r, f = [email protected], ovlp = 50, soglia = soglia, 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) #Parametri di frequenza dominante y <- seewave::dfreq(r, f = [email protected], wl = wl, ylim=c(0, 280/1000), ovlp = 0, plot = F, soglia = soglia, passa banda = b * 1000, fftw = TRUE)[, 2] meandom <- mean(y, na.rm = TRUE) mindom <- min(y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom - mindom) duration <- (end - start) #modulation index Il calcolo cambia <- vector() for(j in cui(!is. na(y))){ cambia <- abs(y[j] - y[j + 1]) cambia <- append(cambia, cambia) } if(mindom==maxdom) modindx<-0 else modindx <- mean (changes, na.rm = T)/dfrange #save results return(c(duration, meanfreq, sd, median, Q25, Q75, IQR, skew, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx)) })) #change risultati nomi rownames(x) <- c("duration", "meanfreq", "sd", "median", "Q25", "Q75", "IQR", "skew", "kurt", "sp.ent", "sfm", "mode", "centroid", "peakf", "meanfun", "minfun", "maxfun", "meandom", "mindom", "maxdom", "dfrange", "modindx") x <- data.frame(sound.files, selec, as.data.frame(t(x))) colnames(x)[1:2] <- c("sound.files", "selec") nomiriga(x) <- c(1:nrow(x)) return(x) }

processFolder <- function(folderName) { # Inizia con data.frame vuoto. data <- data.frame() # Recupera l'elenco dei file nella cartella. list <- list.files(folderName, '\.wav') # Aggiunge l'elenco dei file a data.frame per l'elaborazione. for (fileName nell'elenco) { row <- data.frame(fileName, 0, 0, 20) data <- rbind(data, row) } # Imposta i nomi delle colonne. nomi(dati) <- c('sound.files', 'selec', 'start', 'end') # Sposta nella cartella per l'elaborazione. setwd(nomecartella) # Elabora i file. acustica <- specan3(data, parallel=1) # Torna nella cartella principale. setwd('..') acustica }

gender <- function(filePath) { if (!exists('genderBoosted')) { load('model.bin') } # Percorsi di installazione. currentPath <- getwd() fileName <- basename(filePath) percorso <- dirname(filePath) # Imposta la directory per leggere il file. setwd(percorso) # Inizia con data.frame vuoto. data <- data.frame(fileName, 0, 0, 20) # Imposta i nomi delle colonne. nomi(dati) <- c('sound.files', 'selec', 'start', 'end') # Elabora i file. acustica <- specan3(data, parallel=1) # Ripristina il percorso. setwd(currentPath) forecast(genderCombo, newdata=acoustics) }

# Caricare dati

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

# Imposta etichette.

perdita$etichetta <- 1 senza_perdita$label <- 2 dati <- rbind(perdita, senza_perdita) data$label <- factor(data$label, etichette=c('perdita', 'senza_perdita'))

# Rimuovi le colonne inutilizzate.

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

# Rimuovi le righe che contengono NA.

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

# Scrivi il set di dati CSV.

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

Passaggio 11: ridefinizione neurale

A idea do uso de uma rede neural, é a de realizar um reconhecimento automatizzato através dos dados coletados pelo device de sensoriamento.

Un nuovo utilizzo neurale è del tipo MLP (Multilayer Perceptron), questo modello è treinato con dati previamente identificati e após esse treinamento o modello impiantato senza sistema conseguirá realizzare un'identificazione automatica del sinal recebido, informando se naquele ponto esiste um vazamento ou não.

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 superficiale 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%, come pode ser servado na imagem anexa.

Este algoritmo é utilizado para treinar o modelo da rede e retornar a taxa de acerto do mesmo. No sistema 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.

# codifica: utf-8

importa panda come pd

importa numpy come np da sklearn.model_selection importa train_test_split come tts da sklearn.neural_network importa MLPClassifier come MLP da sklearn.metrics importa ranking_report come cr da sklearn.metrics importa confusione_matrix come cm

# Leitura dos dados do CSV

df = pd.read_csv('features.csv') # Separazione delle entrate df_X = df[df.columns[:len(df.columns)-1] # Filtrando come entrate 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 il modello di rigenerazione neurale

modelo = MLP(alpha=0.0001, learning_rate_init=0.0001, hidden_layer_sizes=(50, 50, 50, 50), max_iter=10000, attivazione='tanh', solutore='lbfgs')

# Treinando modello

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

# Imprimindo risultati

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 (rapporto)