Sistema Autônomo Localizador De Vazamentos : 11 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Este projeto consist em um robô, que atraves 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 espectros das vibrações no solo, pode identificar e localizar, com o processamento dos dados por uma rede espectros das vibrações no solo, pode identificar e localizar, com o processamento dos dados por uma rede espectros das vibrações no solo, pode identificar e localizar, com o processamento dos dados por uma rede espectros das vibrações no solo, pode identificar e localizar, com o processamento dos dados por uma rede espectros das vibrações no solo, uma tubulação.

O processamento destes dados é realizado por algoritmos 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 (FACEENS), participaram do projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigues, Rogério Ap. Polo Gomes et Polo Ronaldo P. Gomes. Participe au projet 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 et Felipe Crispim da Silva Salvagnini.

Étape 1: Liste de matériaux

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

1 Arduino dû

1 Dragonboard 410c

2 Drivers para motor de corrente continua prétendo cada um:

4 transistors BC548

4 Diodes 1n4007

4 Résistances 4k7Ω W

1 pilote pour servomoteur concurrent:

1 Transistor BC548

1 Diode 1N4007

1 Résistances 4k7Ω W

1 souris USB

1 USB Teclado

1 moniteur

1 prise HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira et engrenagem

1 servomoteur 9g

Étape 2: Adaptação Mecânica

Para 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, neste caso as peças foram fabricadas por uma impressora 3D, devido ao de curtipo de se tratare tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme vídeo.

Étape 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, conform as figuras acima, sendo a primeira figura o driver para um motor de corrente continua ea segunda o driver para um servomoteur.

Étape 4: Obtenção Do Audio

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 T vovos sobre sobre o TCC envoyez un courriel à [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.

En tant que fréquences d'intérêt pour le projet entre 100 Hz et 800 Hz. 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 vezuda aquêda d.

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

Étape 5: Configuração Do Arduino DUE (linguage 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 necessários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado o Arduino mai DUE para fazer uso de uma entrada com Poder de processamento, qui est nécessaire pour le bouclier d'interface de Grove Seeed Sensor Mezzanine installé sur DRAGONBOARD 410c, qui possède un microcontrôleur ATmega 328, qui n'a pas de pouvoir de traitement pour un fonctionnement rapide.

O Arduino DUE a été configuré pour recevoir les commandes de la plate-forme QUALCOMM DRAGONBOARD 410c via la communication en série.

Comme ações configuradas no foram Arduino:

Réaliser une acquisition dos dados;

Transmitir os dados obtidos para a DRAGONBOARD 410c;

Enchaîner une programmation:

#include#define Numb_Sample 3000 #define DAC_Input A0

#définir SERVO 7

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

1); // 50% du cycle de service

TC_SetRC(tc, canal, rc); TC_Start(tc, canal); tc->TC_CHANNEL[canal]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // Habilita os registradores tc->TC_CHANNEL[channel]. TC_IDR = ~(TC_IER_CPCS | TC_IER_CPAS); // désactive les registres NVIC_EnableIRQ(irq); // capacité d'interruption }

void setup ()

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

boucle vide()

{ /*//while(!Serial.available()); char rc;//=Serial.read(); indice entier = 0; if(rc==0) { while(!Serial.available()); rc=Série.read(); switch(rc) { cas 1: indice=0; while(!Serial.available()); while((rc=Serial.read())!=0xFF) { indice <<= 8; indice += rc; while(!Serial.available()); } Serial.print(0); Serial.print(2); SendNumber(DAC[indice]); Serial.print(0xFF); Pause; cas 3: while(!Serial.available()); if((Serial.read())==0xFF) { SNow=PosServoMax; retard (500); ind=0; //TC_Start(TC1, 0); while(ind<Num_Sample); //TC_Stop(TC1, 0); SNow=PosServoMin; retard (500); Serial.print(0); Serial.print(4); Serial.print(0xFF); } Pause; } } else if(rc=='2') { Serial.print("Test Servo Motor\n"); while(!Serial.available()); rc=Série.read(); if(rc=='1') { Serial.print("Mode 1\n"); SNow=PosServoMax; } if(rc=='2') { Serial.print("Mode 2\n"); SNow=PosServoMin; } } */ SNow=PosServoMax; retard (100); SNow=PosServoMin; retard (100); }

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

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

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

Remarque: 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. Par isso optou-se pelo interfaceamento USB, que necessitaria da recompilação do KERNEL na DRAGONBOARD 410c pour un porta fosse criada corretamente para a comunicação.

import timeimport serial import pandas as pd import numpy as 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('Entrez vos commandes ci-dessous.\r\nInsérez "exit" pour quitter l'application.')

entrée=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

liste =

pour i dans la plage (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)

Étape 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 projecto, para valores numéricos, que são utilizados de on a algorit 410c. 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.

# codage: utf-8

# Lecture et conversation des audios pour csv

# MDULOS UTILIZADOS

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(signal), pd. DataFrame(Time)], axis=1) df.to_csv(file_name + '.csv', index=False) return df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

nom_fichier = 'Solo_com_Vazamento' df_vazamento = audio_to_csv(nom_fichier) df_vazamento.columns = ['amp', 'temps'] nom_fichier = 'Solo_sem_Vazamento' df_sem_vazamento = audio_to_csv_csv_sf(sem'amp_co)

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

Étape 9: Analysez 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 suasem amplitudes, que compõnal analisar as varias frequências, e suasem amplitudes, que compõnal 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 graphiques 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.

# codage: utf-8# Modules utilizados para processamento da transformada de Fourier

importer des pandas en tant que pd importer numpy en tant que np importer la vague de matplotlib importer pyplot en tant que plt# # 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[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('Temps') 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 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 si init*44100 > len(df) ou final*44100 > len(df): init = (len(df)/44100)-delta si init =100) & (df['freq ']<=800)] mx = trié(df['amp']) print("Média das amplitudes:", np.round(np.mean(mx))) print("Percentuais em relação a media das amplitudes.") print("100 maiores amplitudes ", np.mean(mx[-100:])//df['amp'].mean()*100, "%", sep="") print("50 maiores amplitudes:", np.mean(mx[-50:])//df ['amp'].mean()*100, "%", sep="") print("10 maiores amplitudes:", np.mean(mx[-10:])//df['amp']. moyenne()*100, "%", sep="") print("Maior amplitude:", np.mean(mx[-1:])//df['amp'].mean()*100, " %", sep="")read_csv('Solo_com_Vazamento', 2, 10) # Exemple de graphique pour vazamentoread_csv('Solo_sem_Vazamento', 2, 10) # Exemple de graphique pour sem vazamento

Étape 10: Algoritmo Em R Para Extração Das Caractéristiques Dos Dados

Utilizou-se um algoritmo em R pour realizar o processamento e extração das features (características) dos dados obtidos.

Este premieriro 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 resultantes desse processo serveão para o treinamento 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 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 audio capturado, abaixo seguirá uma descrição (em francês) destas características.

Este algoritmo faz parte de um projeto disponível no GitHub e pode ser acessado atraves deste link, o mesmo foi modificado para atender as especificações do projeto.

O software usado para rodar o algoritmo é gratuito, download do interpretador Re do R Studio.

Caractéristiques extraídas:

• Meanfreq: fréquence moyenne (en kHz)
• sd: écart type de fréquence
• médiane: fréquence médiane (en kHz)
• Q25: premier quantile (en kHz)
• Q75: troisième quantile (en kHz)
• IQR: gamme interquantile (en kHz)
• skew: skewness (voir note dans la description specprop)
• kurt: kurtosis (voir la note dans la description de specprop)
• sp.ent: entropie spectrale
• sfm: planéité spectrale
• mode: fréquence de mode
• centroïde: fréquence centroïde (voir specprop)
• peakf: fréquence de crête (fréquence avec l'énergie la plus élevée)
• Meanfun: moyenne de la fréquence fondamentale mesurée à travers le signal acoustique
• minfun: fréquence fondamentale minimale mesurée à travers le signal acoustique
• maxfun: fréquence fondamentale maximale mesurée à travers le signal acoustique
• moyenne: moyenne de la fréquence dominante mesurée à travers le signal acoustique
• mindom: minimum de fréquence dominante mesurée à travers le signal acoustique
• maxdom: maximum de la fréquence dominante mesurée à travers le signal acoustique
• dfrange: plage de fréquence dominante mesurée à travers le signal acoustique
• modindx: indice de modulation. Calculé comme la différence absolue accumulée entre des mesures adjacentes de fréquences fondamentales divisées par la gamme de fréquences
• libellé: fuite ou sans_leakage

Algoritmo utilisé:

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

bibliothèque (tuneR)

bibliothèque (seewave) bibliothèque (caTools) bibliothèque (rpart) bibliothèque (rpart.plot) bibliothèque (randomForest) bibliothèque (warbleR) bibliothèque (souris) bibliothèque (xgboost) bibliothèque (e1071)

specan3 <- function(X, bp = c(0, 22), wl = 2048, seuil = 5, parallel = 1){ # Pour utiliser le traitement parallèle: 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)) selec <- as.character(unlist(X$selec)) } else stop(paste(paste(c("sound.files", "selec", "start", "end")[!(c("sound.files", "selec", "start", "end") %in% colnames(X))], collapse=", "), "column(s) not found in data frame")) } else stop("X n'est pas un data frame") #s'il y a des NA au début ou à la fin stop if(any(is.na(c(end, start)))) stop("NAs found in start et/ou end") #if end ou start ne sont pas un stop numérique if(all(class(end) != "numeric" & class(start) != "numeric")) stop("'end' et 'selec' doivent être numériques") #si tout début supérieur à la fin stop if(any(end - start<0)) stop(paste("Le début est supérieur à en d dans", longueur(qui(fin - début20)) stop(coller(longueur(qui(fin - début>20)), "sélection(s) de plus de 20 sec")) options(show.error.messages = TRUE) #if bp n'est pas un vecteur ou une longueur!=2 stop if(!is.vector(bp)) stop("'bp' doit être un vecteur numérique de longueur 2") else{ if(!length(bp) == 2) stop("'bp' doit être un vecteur numérique de longueur 2")} #return avertissement si tous les fichiers son n'ont pas été trouvés 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))-length(unique(sound.files[(sound.files %in% fs)])), ".wav file(s) not found")) #count nombre de fichiers son dans le répertoire de travail et si 0 stop d <- which(sound.files %in% fs) if(length(d) == 0){ stop("Les fichiers.wav ne sont pas dans le répertoire de travail") } else { start <- start[d] end <- end[d] selec <- selec[d] sound.files <- sound.files[d] } # Si parallel n'est pas numérique if(!is.numeric(parallel)) stop("'parallel' doit être un vecteur numérique de longueur 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("Les utilisateurs de Windows doivent installer le package 'parallelsugar' pour le calcul parallèle (vous ne le faites pas maintenant !)") 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("Mesure des paramètres acoustiques:") x <- as.data.frame(lapp(1:length(start), function(i) { r <- tuneR::readWave(file.path(getwd(), sound.files), from = start, to = end, units = "seconds") b plafond([email protected]/2000) - 1) b[2] <- plafond([email protected]/2000) - 1 #analyse du spectre de fréquence songspec <- seewave::spec(r, f = [email protected], plot = FALSE) analyse <- 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 < - 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 #Frequency with amplitude peaks peakf <- 0#seewave::fpeaks(songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE)[1, 1] #Paramètres de fréquence fondamentaux ff <- seewave::fund(r, f = [email protected], ovlp = 50, seuil = seuil, 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) #Paramètres de fréquence dominants y <- seewave::dfreq(r, f = [email protected], wl = wl, ylim=c(0, 280/1000), ovlp = 0, plot = F, seuil = seuil, bande passante = 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 calcul change <- vector() for(j in which(!is. na(y))){ change <- abs(y[j] - y[j + 1]) change <- append(changes, change) } if(mindom==maxdom) modindx<-0 else modindx <- Mean (changes, na.rm = T)/dfrange #enregistrer les résultats 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)) })) #changer les noms des résultats 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") rownames(x) <- c(1:nrow(x)) return(x) }

processFolder <- function(folderName) { # Commence avec data.frame vide. data <- data.frame() # Récupère la liste des fichiers dans le dossier. list <- list.files(folderName, '\.wav') # Ajoute la liste de fichiers à data.frame pour traitement. for (fileName in list) { row <- data.frame(fileName, 0, 0, 20) data <- rbind(data, row) } # Définir les noms de colonnes. names(data) <- c('sound.files', 'selec', 'start', 'end') # Déplacez-vous dans le dossier pour le traitement. setwd(folderName) # Traiter les fichiers. acoustics <- specan3(data, parallel=1) # Revenir dans le dossier parent. setwd('..') acoustique }

gender <- function(filePath) { if (!exists('genderBoosted')) { load('model.bin') } # Chemins d'installation. currentPath <- getwd() fileName <- basename(filePath) path <- dirname(filePath) # Définit le répertoire pour lire le fichier. setwd(chemin) # Commence par un data.frame vide. data <- data.frame(fileName, 0, 0, 20) # Définit les noms de colonnes. names(data) <- c('sound.files', 'selec', 'start', 'end') # Traiter les fichiers. acoustique <- specan3(data, parallel=1) # Chemin de restauration. setwd(currentPath) predict(genderCombo, newdata=acoustics) }

# Charger les données

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

# Définir des étiquettes.

leak$label <- 1 without_leakage$label <- 2 data <- rbind(leakage, without_leakage) data$label <- factor(data$label, labels=c('leakage', 'without_leakage'))

# Supprimez les colonnes inutilisées.

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

# Supprimez les lignes contenant des NA.

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

# Écrivez l'ensemble de données csv.

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

Étape 11: Rede Neural

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

A rede neural utilizada é do tipo MLP (Multilayer Perceptron), este modelo é treinado com dados previamente identificados e após esse treinamento o modelo implantado no sistema conseguirá realizar a identificação automática do sinal recebido, informando se naqueumle in sistema conseguirá realizar a identificação automática do sinal recebido, informando se naqueumle

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, masmo com um trabalho mais superficiel 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 of acerto de 100%, come pode ser observado 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.

# codage: utf-8

importer des pandas au format pd

importer numpy en tant que np de sklearn.model_selection importer train_test_split en tant que tts de sklearn.neural_network importer MLPClassifier en tant que MLP de sklearn.metrics importer classification_report en tant que cr de sklearn.metrics importer confusion_matrix en cm

# Leitura dos dados do CSV

df = pd.read_csv('features.csv') # Séparation des entrées df_X = df[df.columns[:len(df.columns)-1] # Filtrando as entradas df_X = df_X

# Separando dados para treino e teste

X_train, X_test, Y_train, Y_test = tts(df_X, df_Y, test_size=0.1)

# Criando 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')

# Modèle Treinando

modelo.fit(X_train, Y_train) résultat = 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 (rapport)