Sistema Autônomo Localizador De Vazamentos - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Este projeto bestaat uit een 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 gua locizar, com o processamento dos dados por uma tubulação.

O processamento destes dados é realizado door algoritmos instalados op DRAGONBOARD 410c. Het is een goed idee om een dienst na te streven, een antwoord op een ander proces van 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 Xavidrier, Lucas de Sousa Rodrigues. Gomes Polo en Ronaldo P. Gomes Polo. Também participou do projeto of alumo Daniel de Castro Pacheco afgestudeerde de engenharia mecanica aan Universidade Newton Paiva de Belo Horizonte. O projeto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro en Felipe Crispim da Silva Salvagnini.

Stap 1: Lista De Materiais

Voor de realisatie van het projeto, os seguintes materiais foram utilizados:

1 Arduino Due

1 Dragonboard 410c

2 Drivers para motor de corrente continua cada um:

4 Transistors BC548

4 Diodo's 1n4007

4 Weerstanden 4k7Ω ¼ W

1 Driver voor servomotor strijd:

1 Transistors BC548

1 Diodos 1N4007

1 Weerstanden 4k7Ω ¼ W

1 muis USB

1 Teclado-USB

1 monitor

1 kabel HDMI

1 Robo De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira en engrenagem

1 servomotor 9g

Stap 2: Adaptação Mecanica

Para aquisição dos dados pelo sensor piezoelétrico, faz se necessário, of desenvolvimento de um dispositivo com pinhão e cremalheira, conforme desenhos anexados, neste caso as peças foram fabricadas por umavidoora 3D tempo de execução, fixou-se of dispositivo op plataforma zumo, utilizando fita dupla face, conforme vídeo.

Stap 3: Acionamento Dos Motores

Para executar a motion dos motores do robô ZUMO en do dispositivo de captura, fez-se necessária een 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 of driver para um servomotor.

Stap 4: Obtenção Do Áudio

Voor het uitvoeren van een audiospectro is het vibrações doen 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 thetalCC e-mail [email protected].

Este dispositivo utilizativo de um sensor piezoelétrico uma placa de circuito que realiza a filtragem and amplificaço do sinal.

Als frequências de interesse para o projeto estão tussen 100Hz en 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 peloze quaas ac

Een aquisição é habilitada en desabilitada através da interrupço do Arduino DUE.

Stap 5: Configuração Do Arduino DUE (linguagem C)

Devido a grande quantidade de dados, cerca de 3000 pontos por segundo, do tipo inteiro de 32 bits, gerados pelo dispositivo de sensoriamento en necessários para processamento dos algoritmos na DRAGONBOARD 410c, foi UE utilizadozero uso Processamento, isso nodig voor de interface en Shield van de interface Grove Seeed Sensor Mezzanine geïnstalleerd op DRAGONBOARD 410c, heeft een microcontrolemechanisme ATmega 328, geen mogelijkheid om processamento voor de operatie te openen.

O Arduino DUE kan worden geconfigureerd voor receber os comandos enviados da plataforma QUALCOMM DRAGONBOARD 410c via comunicação serial.

Zoals configuraties geen Arduino-foram:

Realiseer een aquisição dos dados;

Overdracht van gegevens voor een DRAGONBOARD 410c;

Volg een programma:

#include#define Numb_Sample 3000 #define DAC_Input A0

#definieer SERVO 7

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

1); // 50% inschakelduur

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

ongeldige instelling ()

{ Serieel.begin(115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500);//Start de timer //TC_Stop (TC1, 0); pinMode (SERVO, UITGANG); }

lege lus()

{ /*//while(!Serial.available()); char rc;//=Serial.read(); int-index = 0; if(rc==0) { while(!Serial.available()); rc=Seriële.lezen(); switch (rc) { geval 1: index = 0; while(!Serial.available()); while((rc=Serial.read())!=0xFF) { index <<= 8; index += rc; while(!Serial.available()); } Serieel.print(0); Serieafdruk(2); SendNumber(DAC[index]); Seriële.afdruk (0xFF); pauze; geval 3: while(!Serial.available()); if((Serial.read())==0xFF) { SNow=PosServoMax; vertraging (500); ind=0; //TC_Start (TC1, 0); while(ind<Numb_Sample); //TC_Stop (TC1, 0); SNow=PosServoMin; vertraging (500); Serieafdruk(0); Serieafdruk(4); Seriële.afdruk (0xFF); } pauze; } } else if(rc=='2') { Serial.print("Test servomotor\n"); while(!Serial.available()); rc=Seriële.lezen(); if(rc=='1') { Serial.print("Modus 1\n"); SNow=PosServoMax; } if(rc=='2') { Serial.print("Modus 2\n"); SNow=PosServoMin; } } */ SNow=PosServoMax; vertraging (100); SNow=PosServoMin; vertraging (100); }

Stap 6: Interfaceamento Das Tecnologias

Para a comunicação dos dados andtre o Arduíno DUE en DRAGONBOARD 410c, inicialmente utilizou-se a interface da figura acima, o que não foi possível executar, então optou-se pelo uso de uma o USB CDCUE noodzaak om de KERNEL van DRAGONBOARD 410c te hercompileren, die niet kan worden opgelost door de korte termijn disponível.

Stap 7: Configureer Da DRAGONBOARD 410c (Python)

U kunt de configuratie van Arduino DUE configureren voor het realiseren van een aquisição de dados en transmissie van dados obtidos. Segue codigo abaixo.

Opmerking: Een 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. Het is ook mogelijk om een USB-interface te maken, die nodig is om de KERNEL op de DRAGONBOARD 410c te kunnen aansluiten voor een communicatie-uitbreiding.

import timeimport serieel import panda's als pd import numpy als 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('Voer hieronder uw commando's in.\r\nVoer "exit" in om de applicatie te verlaten.')

invoer=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 transmitter os dados coletados

lijst =

voor i binnen bereik (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)

Stap 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, see fez necessária a conversão dos arquivos no formato WAV, fornecidos pelos alunos autores do TCC en colaboradores do projeto, para valores numéricos,utilque são arquivos formato WAV, fornecidos pelos alunos autores do TCC en colaboradores do projeto, para valores numéricos,utilque são allaARD. Voor een realizar esta conversão foi escrito um algoritmo em PYTHON 3 que lê o arquivo WAV en salva os dados do espectro em um arquivo CSV. O algoritmo utilizado segue abaixo en em anexo para download.

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

# codering: utf-8

# Leitura en conversão dos audios para csv

# MÓDULOS UTILIZADOS

import wave import numpy als np import panda's als pd import matplotlib.pyplot als plt

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

def audio_to_csv(bestandsnaam): 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) signaal = 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(signaal), 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_cszamento = audio_to_cszamed(file_name)

# GRÁFICO DO ESPECTRO DE AUDIO

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

Stap 9: Analyseer Visual Do Sinal

Com o PYTHON 3 é realizada a transformada the Fourier, est 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, que susaem amplitudes. Een visuele analyse van de transformatie van Fourier en profissional met specifieke kenmerken van het bestaan van een algum vazamento na tubulação. Estes grafische diensten voor validação das análises realizadas pelo algoritmo the detecção automática.

Beperkte frequenties van frequenties tussen 100 Hz en 800 Hz, een duidelijk bestaand bestaan van frequenties die kunnen worden waargenomen in het frequentiebereik.

# codering: utf-8# Gebruiksvoorwerpen voor het proces van transformatie van Fourier

importeer panda's als pd importeer numpy als np importeer wave uit matplotlib importeer pyplot als plt# Functie om een Fourier-transformatie te realiseren en een analyse te maken van Fourier(df_list): Fs = 44100; # Taxa de amostragem em Hz Ts = 1,0/Fs; # Interval van 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[bereik(n//2)] Y = np.fft.fft(y)/n Y = Y[bereik(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('Tijd') 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 en 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) of final*44100 > len(df): init = (len(df)/44100)-delta if init =100) & (df['freq ']<=800)] mx = gesorteerd(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 amplitudes:", np.mean(mx[-50:])//df ['amp'].mean()*100, "%", sep="") print("10 maiores amplitudes:", np.mean(mx[-10:])//df['amp']. mean()*100, "%", sep="") print("Grote amplitude:", np.mean(mx[-1:])//df['amp'].mean()*100, " %", sep="")read_csv('Solo_com_Vazamento', 2, 10) # Grafische voorbeelden van vazamentoread_csv('Solo_sem_Vazamento', 2, 10) # Grafische voorbeelden van vazamento

Stap 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 Audio trata-se de uma amostra vazamento detectado ou não, isso por que os dados resultantes desse processo servirão Add-Treinamento da rede neurale 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 oa espectro de áudio capturado, abaixo seguirá uma descrição (em ingles) destas características.

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

Gebruik software voor rodar of gratis, download interpretador R e do R Studio.

Extra's kenmerken:

• gemiddelde frequentie: gemiddelde frequentie (in kHz)
• sd: standaarddeviatie van frequentie
• mediaan: mediaan frequentie (in kHz)
• Q25: eerste kwantiel (in kHz)
• Q75: derde kwantiel (in kHz)
• IQR: interkwantielbereik (in kHz)
• scheefheid: scheefheid (zie opmerking in specpropbeschrijving)
• kurt: kurtosis (zie opmerking in specpropbeschrijving)
• sp.ent: spectrale entropie
• sfm: spectrale vlakheid
• modus: modus frequentie
• zwaartepunt: frequentiezwaartepunt (zie specprop)
• peakf: piekfrequentie (frequentie met de hoogste energie)
• meanfun: gemiddelde van fundamentele frequentie gemeten over akoestisch signaal
• minfun: minimale grondfrequentie gemeten over akoestisch signaal
• maxfun: maximale grondfrequentie gemeten over akoestisch signaal
• meandom: gemiddelde van dominante frequentie gemeten over akoestisch signaal
• mindom: minimum van dominante frequentie gemeten over akoestisch signaal
• maxdom: maximum van dominante frequentie gemeten over akoestisch signaal
• dfrange: bereik van dominante frequentie gemeten over akoestisch signaal
• modindx: modulatie-index. Berekend als het geaccumuleerde absolute verschil tussen aangrenzende metingen van fundamentele frequenties gedeeld door het frequentiebereik
• label: lekkage of zonder_lekkage

Algoritmisch gebruik:

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

bibliotheek (tuner)

bibliotheek(seewave) bibliotheek(caTools) bibliotheek(rpart) bibliotheek(rpart.plot) bibliotheek(randomForest) bibliotheek(warbleR) bibliotheek(muizen) bibliotheek(xgboost) bibliotheek(e1071)

specan3 <- function(X, bp = c(0, 22), wl = 2048, threshold = 5, parallel = 1){ # Om parallelle verwerking te gebruiken: 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))], collaps=", "), "kolom(men) niet gevonden in dataframe")) else stop("X is geen dataframe") #als er NA's zijn in start of eindstop if(any(is.na(c(end, start)))) stop("NA's gevonden in start en/of einde") #if end of start zijn geen numerieke stop if(all(class(end) != "numeric" & class(start) != "numeric")) stop("'end' en 'selec' moeten numeriek zijn") #if elke start hoger dan eind stop if(any(end - start<0)) stop(paste("De start is hoger dan de en d in", lengte(welke(eind - begin20)) stop(plakken(lengte(welke(eind - begin>20)), "selectie(s) langer dan 20 sec")) options(show.error.messages = TRUE) #if bp is geen vector of lengte!=2 stop if(!is.vector(bp)) stop("'bp' moet een numerieke vector met lengte 2") else{ if(!length(bp) == 2) stop("'bp' moet een numerieke vector van lengte 2")} #return waarschuwing als niet alle geluidsbestanden gevonden zijn fs <- list.files(path = getwd(), pattern = ".wav$", negeer.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")) #tel het aantal geluidsbestanden in de werkmap en als 0 stopt d <- that(sound.files %in% fs) if(length(d) == 0){ stop("De.wav-bestanden staan niet in de werkdirectory") } else { start <- start[d] end <- end[d] selec <- selec[d] sound.files <- sound.files[d] } # Als parallel niet numeriek is if(!is.numeric(parallel)) stop("'parallel' must wees een numerieke vector met lengte 1") if(any(!(parallel %% 1 == 0), parallel 1) { options(warn = -1) if(all(Sys.info()[1] == " Windows", requiredNamespace("parallelsugar", still = TRUE) == TRUE)) lapp <- function(X, FUN) parallelsugar::mclapply(X, FUN, mc.cores = parallel) else if(Sys.info() [1] == "Windows"){ cat("Windows-gebruikers moeten het 'parallelsuiker'-pakket installeren voor parallel computergebruik (u doet het nu niet!)") 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("Akoestische parameters meten:") 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 #frequentiespectrumanalyse 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 mediaan <- analysis$mediaan/1000 Q25 < - analyse$QQ75 <- analyse$QIQR <- analyse$IQR/1000 scheefheid <- analyse$skewness kurt <- analyse$kurtosis sp.ent <- analyse$sh sfm <- analyse$sfm modus <- analyse$mode/1000 zwaartepunt <- analyse$cent/1000 #Frequentie met amplitudepieken peakf <- 0#seewave::fpeaks(songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE)[1, 1] #Fundamentele frequentieparameters ff <- seewave::fund(r, f = [email protected], ovlp = 50, drempel = drempel, 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) #Dominante frequentieparameters y <- seewave::dfreq(r, f = [email protected], wl = wl, ylim=c(0, 280/1000), ovlp = 0, plot = F, drempel = drempel, bandpass = 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) duur <- (end - start) #modulatie indexberekening verandert <- vector() for(j waarin(!is. na(y))){ change <- abs(y[j] - y[j + 1]) changes <- append(changes, change) } if(mindom==maxdom) modindx<-0 else modindx <- mean (wijzigingen, na.rm = T)/dfrange #save results return(c(duration, meanfreq, sd, mediaan, Q25, Q75, IQR, skew, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx)) })) #change result names rownames(x) <- c("duration", "meanfreq", "sd", "mediaan", "Q25", "Q75", "IQR", "skew", "kurt", "sp.ent", "sfm", "mode", "zwaartepunt", "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) { # Begin met leeg data.frame. data <- data.frame() # Verkrijg een lijst met bestanden in de map. list <- list.files(folderName, '\.wav') # Voeg bestandslijst toe aan data.frame voor verwerking. for (fileName in list) { row <- data.frame(fileName, 0, 0, 20) data <- rbind(data, row) } # Stel kolomnamen in. name(data) <- c('sound.files', 'selec', 'start', 'end') # Verplaats naar map voor verwerking. setwd(mapnaam) # Verwerk bestanden. akoestiek <- specan3(data, parallel=1) # Ga terug naar de bovenliggende map. setwd('..') akoestiek }

gender <- function(filePath) { if (!exists('genderBoosted')) { load('model.bin') } # Setup-paden. currentPath <- getwd() fileName <- basename(filePath) path <- dirname(filePath) # Stel de directory in om het bestand te lezen. setwd(path) # Begin met een leeg data.frame. data <- data.frame(fileName, 0, 0, 20) # Stel kolomnamen in. name(data) <- c('sound.files', 'selec', 'start', 'end') # Verwerk bestanden. akoestiek <- specan3(data, parallel=1) # Herstel pad. setwd(currentPath) predict(genderCombo, newdata=acoustics) }

# Gegevens laden

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

# Stel labels in.

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

# Verwijder ongebruikte kolommen.

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

# Verwijder rijen met NA's.

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

# Schrijf de csv-dataset uit.

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

Stap 11: Neurale opnieuw maken

Een idee om de uma rede neural te gebruiken, is een realizar um reconhecimento automatizado attravé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 trainamento o modelo implantado no sistema conseguirá a identificação o e sinal reseebidoque e após esse treinamento o modelo implantado o sistema conseguirá a identificação o e sinal recebidoque o einformando

Er moet een realizar bestaan van filtragem van de entrada, de karakters van de algumas die diminuindo een taxa de acerto da rede en invés de melhora-la. Niets is te zien aan de hand van de gegevens over de geschiedenis van de geschiedenis, meer informatie over het gebruik van oppervlakkige pode-se chegar en algums variáveis com bons desempenhos.

Para os testes realizados o modelo obteve um desempenho muito bom, alcando op maioria dos testes uma taxa de acerto de 100%, como pode ser observado on imagem anexa.

Este algoritmo é utilizado para treinar of modelo da rede e retornar a taxa de acerto do mesmo. Er is geen bewijs van een algoritmum dat kan worden gebruikt voor het maken van een realistische versie van het model of een nieuw ontwerp van een nieuw model van de werkelijkheid als predicaat voor het cada leitura realizada.

# codering: utf-8

panda's importeren als pd

importeer numpy als np van sklearn.model_selection importeer train_test_split als tts van sklearn.neural_network importeer MLPClassifier als MLP van sklearn.metrics importeer classificatie_report als cr van sklearn.metrics importeer verwarring_matrix als cm

# Leitura dos dados do CSV

df = pd.read_csv('features.csv') # Gescheiden tussen df_X = df[df.columns[:len(df.columns)-1] # Filtrando as tussen 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, activatie='tanh', solver='lbfgs')

# Treinando modelo

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

# Imprimindo-resultaten

report = cr(Y_test, resultaat) 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 (verslag doen van)