Sistema Autonomo Localizador De Vazamentos – Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:17

Este projeto consiste em um robô, que através da leitura realizada por um dispositivo, equido com um sensor piezoelétrico, captura os espectros das vibrações no solo, pode identificar e localizar, com o processamento dos dados porápos guaosí de neural, 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 (FACENS), participaram do projeto os graduandos de engharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigue. Gomes Polo und Ronaldo P. Gomes Polo. Também participou do projeto oder aluno Daniel de Castro Pacheco graduando de Engharia mecânica an der Universidade Newton Paiva de Belo Horizonte. O projeto contou com o apoio dos graduandos de engharia mecatrônica da FACENS, Lucas Nunes Monteiro und Felipe Crispim da Silva Salvagnini.

Schritt 1: Lista De Materiais

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

1 Arduino Due

1 Drachenbrett 410c

2 Drivers para motor de corrente continua contendo cada um:

4 Transistoren BC548

4 Diodos 1n4007

4 Widerstände 4k7Ω ¼ W

1 Treiber für Servomotor-Contendo:

1 Transistoren BC548

1 Diodos 1N4007

1 Widerstände 4k7Ω ¼ W

1 Maus USB

1 Teclado-USB

1 Monitor

1 Cabo-HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini-Dispositiv de crimalheira e engrenagem

1 Servomotor 9g

Schritt 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, neste caso as peças foram Fabricadas por uma impressora 3D, de devido ao de fato tempo de execução, fixou-se oder dispositivo na plataforma zumo, utilizando fita dupla face, konformes video.

Schritt 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 driver 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 oder Treiber für Servomotor.

Schritt 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 und Felipe C. da Silva Salvagnini, dos maiores do tétalhes do maiores do tétalhes so posité E-Mail an [email protected].

Este dispositivo utiliza-se de um sensor piezoetrico e uma placa de Circuito que realiza a filtragem e amplificação do sinal.

Als Frequenzen des Interesses für das Projekt, das zwischen 100 Hz und 800 Hz liegt. 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.

Aquisição é Habilitada e Desabilitada através of Interrupt of Arduino DUE.

Schritt 5: Konfiguration von Arduino DUE (Sprache C)

Devido a grande quantidade de dados, cerca de 3000 pontos por segundo, do tipo inteiro de 32 bits, gerados pelo dispositivo de sensoriamento ecessários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado fazer. due Verarbeitungsschritt, erforderlich für die erforderliche Abschirmung der Schnittstelle Grove Seeed Sensor Mezzanine-Installation auf DRAGONBOARD 410c, möglicher Mikrocontroller ATmega 328, nicht möglicher Verarbeitungsschritt für den Betrieb.

O Arduino DUE für die Konfiguration des Empfängers von Befehlen auf der Plattform QUALCOMM DRAGONBOARD 410c über die serielle Schnittstelle.

Als ações configuradas kein Arduino-Foram:

Realizar aquisição dos dados;

Transmitir os dados obtidos para a DRAGONBOARD 410c;

Übergeben Sie ein Programm:

#include#define Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7

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

1); // 50% Arbeitszyklus

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); // Deaktivierung der Registrierung von NVIC_EnableIRQ(irq); // Habilitationsunterbrechung }

Leere Einrichtung ()

{Seriell.begin(115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Timer initiieren // TC_Stop (TC1, 0); pinMode (SERVO, AUSGANG); }

Leere Schleife ()

{ /*//while(!Serial.available()); char rc;//=Serial.read(); int-Index = 0; if(rc==0) { while(!Serial.available()); rc=Seriell.read(); switch(rc) {Fall 1: Index=0; while(!Seriell.verfügbar()); while((rc=Serial.read())!=0xFF) { Index <<= 8; Index += rc; while(!Seriell.verfügbar()); } Serial.print(0); Seriendruck (2); SendNumber(DAC[Index]); Serial.print (0xFF); brechen; Fall 3: while(!Serial.available()); if((Serial.read())==0xFF) {SNow=PosServoMax; Verzögerung (500); ind=0; //TC_Start (TC1, 0); while(ind<Numb_Sample); //TC_Stop (TC1, 0); SNow=PosServoMin; Verzögerung (500); Seriendruck (0); Seriendruck (4); Serial.print (0xFF); } brechen; } } else if (rc=='2') {Serial.print("Test Servo Motor\n"); while(!Seriell.verfügbar()); rc=Seriell.read(); if(rc=='1') {Serial.print("Modus 1\n"); SNow=PosServoMax; } if (rc=='2') {Serial.print("Modus 2\n"); SNow=PosServoMin; } } */ SNow=PosServoMax; Verzögerung (100); SNow=PosServoMin; Verzögerung (100); }

Schritt 6: Interfaceamento Das Tecnologias

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

Schritt 7: Konfiguration des DRAGONBOARD 410c (Python)

Konfiguriert für Enviar ua Arduino DUE oder Befehle für Realizar aquisição de dados and sendir os dados obtidos. Segue código abaixo.

Bemerkung: 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 eine optionale USB-Schnittstelle, die eine Neukompilierung von KERNEL auf DRAGONBOARD 410c für eine Porta-Fosse-Korrektur für eine Kommunikation erforderlich macht.

import timeimport seriell import pandas 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('Geben Sie unten Ihre Befehle ein.\r\nFügen Sie "exit" ein, um die Anwendung zu verlassen.')

Eingabe=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 oder comando para oder Arduino DUE sendir os dados coletados

Liste =

für i im Bereich (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)

Schritt 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 format WAV, fornecidos pelos alunos autores do TCC und colaboradores do projeto, para valores numéricos, que nosá alcagorizados na de são alcagorizados na de são alcagorizados. Um eine Konversation für einen Algorithmus mit PYTHON 3 zu erreichen, müssen Sie einen WAV-Arquivo- und einen anderen Datenspeicher verwenden, um einen CSV-Algorithmus zu verwenden. O algoritmo utilizado segue abaixo e em anexo para download.

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

# Codierung: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS-UTILIZADOS

import wave import numpy als np import pandas als pd import matplotlib.pyplot als 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

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 =(_to_namecs'v

# GRÁFICO DO ESPECTRO DE AUDIO

figure, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, figsize=(20, 10)) ax1.plot(df_vazamento['time'], df_vazamento['amp']) ax1.set_title('Solo com Vazamento', fontdict={'fontsize': 20, 'fontweight': 'bold'}) ax1.set_xlabel('Tempo [s]', fontdict={'fontsize': 16}) ax1.set_ylim([-4e8, 4e8]) ax2.plot(df_sem_vazamento['time'], df_sem_vazamento['amp']) ax2.set_title('Solo sem Vazamento', fontdict={'fontsize': 20, 'fontweight': 'bold' }) ax2.set_xlabel('Tempo [s]', fontdict={'fontsize': 16}) ax2.set_ylim([-4e8, 4e8]) figure.tight_layout(h_pad=5) plt.show()

Schritt 9: Visualisieren Sie 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 suasque compalitudes Pela análise visual do gráfico da transformada de Fourier um professionelle 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 oder 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.

# Kodierung: utf-8# Módulos utilizados para processamento da transformada de Fourier

pandas als pd importieren numpy als np importieren Wave aus Matplotlib importieren pyplot als plt# importieren Funktion, die eine Transformation von Fourier und eine grafische Darstellung für die Analyse von Fourier (df_list): Fs = 44100; # Taxa de amotragem em Hz Ts = 1,0/Fs; # Intervall von Amostragem y = pd.concat(df_list) t = y['time'] # Vetor de tempos y = y['amp'] # Vetor de Amplituden 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('Zeit') 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 und 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) oder final*44100 > len(df): init = (len(df)/44100)-delta if init =100) & (df['freq ']<=800)] mx = sortiert(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 Amplituden:", np.mean(mx[-50:])//df ['amp'].mean()*100, "%", sep="") print("10 maiores Amplituden:", np.mean(mx[-10:])//df['amp']. mean()*100, "%", sep="") print("Hauptamplitude:", np.mean(mx[-1:])//df['amp'].mean()*100, " %", sep="")read_csv('Solo_com_Vazamento', 2, 10) # Beispiel für gráficos para vazamentoread_csv('Solo_sem_Vazamento', 2, 10) # Beispiel für gráficos für sem vazamento

Schritt 10: Algoritmo Em R Para Extração Das Features Dos Dados

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

Este primeiro algoritmo realiza uma extração identificada, onde é necessário sabre se o arquivo de áudio trata-se de uma amostra vazamento Detectado ou não, isso por que os dados resultantes desse processo servirão para o neuralnamento da red.

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 bietet ou caraterísticas são proprietades acústicas compostas por varias informações referentes ua espectro de áudio capturado, abaixo seguirá uma descrição (em englês) destas características.

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

O Software Usado Para Rodar oder Algoritmo é gratuito, Download von Interpretador R e do R Studio.

Zusätzliche Merkmale:

• meanfreq: mittlere Frequenz (in kHz)
• sd: Standardabweichung der Frequenz
• Median: Medianfrequenz (in kHz)
• Q25: erstes Quantil (in kHz)
• Q75: drittes Quantil (in kHz)
• IQR: Interquantilenbereich (in kHz)
• skew: Schiefe (siehe Hinweis in Specprop-Beschreibung)
• kurt: kurtosis (siehe Hinweis in Specprop-Beschreibung)
• sp.ent: spektrale Entropie
• sfm: spektrale Flachheit
• Modus: Modusfrequenz
• Schwerpunkt: Frequenzschwerpunkt (siehe Specprop)
• Peakf: Spitzenfrequenz (Frequenz mit der höchsten Energie)
• meanfun: Mittelwert der Grundfrequenz gemessen über das akustische Signal
• minfun: minimale Grundfrequenz gemessen über das akustische Signal
• maxfun: maximale Grundfrequenz gemessen am akustischen Signal
• meandom: Durchschnitt der dominanten Frequenz gemessen über das akustische Signal
• mindom: Minimum der dominanten Frequenz gemessen über das akustische Signal
• maxdom: Maximum der dominanten Frequenz gemessen über das akustische Signal
• dfrange: Bereich der dominanten Frequenz gemessen über das akustische Signal
• modindx: Modulationsindex. Berechnet als akkumulierte absolute Differenz zwischen benachbarten Messungen von Grundfrequenzen geteilt durch den Frequenzbereich
• Label: Leckage oder without_leakage

Algoritmo usado:

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

Bibliothek(tuneR)

Bibliothek(seewave) Bibliothek(caTools) Bibliothek(rpart) Bibliothek(rpart.plot) Bibliothek(randomForest) Bibliothek(warbleR) Bibliothek(Mäuse) Bibliothek(xgboost) Bibliothek(e1071)

specan3 <- function(X, bp = c(0, 22), wl = 2048,threshold = 5, parallel = 1){ # Um parallele Verarbeitung zu verwenden: library(devtools), install_github('nathanvan/parallelsucar') 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))],collap=", "), "Spalte(n) nicht im Datenrahmen gefunden")) } else stop("X ist kein Datenrahmen") #wenn es NAs im Start- oder Endstop gibt if(any(is.na(c(end, start)))) stop("NAs in Start und/oder Ende gefunden") #wenn End oder Start kein numerischer Stop sind if(all(class(end) != "numeric" & class(start) != "numeric")) stop("'end' und 'selec' müssen numerisch sein") #if any start höher als end stop if(any(end - start<0)) stop(paste("Der Anfang ist höher als das en d in", length(which(end - start20)) stop(paste(length(which(end - start>20)), "selection(s) länger als 20 sec")) options(show.error.messages = TRUE) #if bp ist kein Vektor oder Länge!=2 stop if(!is.vector(bp)) stop("'bp' muss ein numerischer Vektor der Länge 2 sein") else{ if(!length(bp) == 2) stop("'bp' muss ein numerischer Vektor der Länge 2 sein")} #return warning wenn nicht alle Sounddateien gefunden wurden 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 Anzahl der Sounddateien im Arbeitsverzeichnis und wenn 0 stop d <- which(sound.files %in% fs) if(length(d) == 0){ stop("Die.wav-Dateien befinden sich nicht im Arbeitsverzeichnis") } else { start <- start[d] end <- end[d] selec <- selec[d] sound.files <- sound.files[d] } # Wenn parallel nicht numerisch ist if(!is.numeric(parallel)) stop("'parallel' must sei ein numerischer Vektor der Länge 1") if(any(!(parallel %% 1 == 0), parallel 1) { options(warn = -1) if(all(Sys.info()[1] == " Windows", requireNamespace("parallelsucar", quietly = TRUE) == TRUE)) lapp <- function(X, FUN) parallelsugar::mclapply(X, FUN, mc.cores = parallel) else if(Sys.info() [1] == "Windows"){ cat("Windows-Benutzer müssen das 'parallelsucar'-Paket für paralleles Rechnen installieren (Sie tun es jetzt nicht!)") 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("Akustische Parameter messen:") 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 Ceiling([email protected]/2000) - 1) b[2] <- Ceiling([email protected]/2000) - 1 #Frequenzspektrumanalyse songspec <- seewave::spec(r, f = [email protected], plot = FALSE) analysis <- 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 < - analyse$QQ75 <- analyse$QIQR <- analyse$IQR/1000 skew <- analyse$schiefe kurt <- analyse$kurtosis sp.ent <- analyse$sh sfm <- analyse$sfm mode <- analyse$mode/1000 centroid <- analysis$cent/1000 #Frequenz mit Amplitudenspitzenpeakf <- 0#seewave::fpeaks(songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE)[1, 1] #Grundlegende Frequenzparameter ff <- seewave::fund(r, f = [email protected], ovlp = 50,threshold =threshold, 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 Frequenzparameter y <- seewave::dfreq(r, f = [email protected], wl = wl, ylim=c(0, 280/1000), ovlp = 0, plot = F, Threshold = Threshold, 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) Dauer <- (end - start) #Modulationsindexberechnung ändert <- vector() for(j in which(!is. na(y))){ change <- abs(y[j] - y[j + 1]) changes <- append(changes, change) } 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)) })) #Ergebnisnamen ändern 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) { # Beginnen Sie mit einem leeren data.frame. data <- data.frame() # Liste der Dateien im Ordner abrufen. list <- list.files(folderName, '\.wav') # Dateiliste zur Verarbeitung in data.frame hinzufügen. for (fileName in list) { row <- data.frame(fileName, 0, 0, 20) data <- rbind(data, row) } # Spaltennamen setzen. names(data) <- c('sound.files', 'selec', 'start', 'end') # Zur Bearbeitung in Ordner verschieben. setwd(folderName) # Dateien verarbeiten. acoustics <- specan3(data, parallel=1) # Zurück in den übergeordneten Ordner verschieben. setwd('..') Akustik }

gender <- function(filePath) { if (!exists('genderBoosted')) { load('model.bin') } # Setup-Pfade. currentPath <- getwd() fileName <- basename(filePath) path <- dirname(filePath) # Verzeichnis zum Lesen der Datei setzen. setwd(path) # Beginnen Sie mit einem leeren data.frame. data <- data.frame(fileName, 0, 0, 20) # Setzt Spaltennamen. names(data) <- c('sound.files', 'selec', 'start', 'end') # Dateien verarbeiten. Akustik <- specan3(data, parallel=1) # Pfad wiederherstellen. setwd(currentPath) Predict(genderCombo, newdata=acoustics) }

# Lade Daten

Leckage <- processFolder('caminho para o Pasta com Samples de áudio com vazamento') without_leakage <- processFolder('caminho para o Pasta com Samples de áudio sem vazamento')

# Etiketten festlegen.

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

# Entfernen Sie nicht verwendete Spalten.

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

# Zeilen mit NAs entfernen.

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

# CSV-Datensatz ausschreiben.

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

Schritt 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 treinnamento oder modelo implantado no sistema conseguirá realizar a identificação automática do sinal recebidole

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 oberflächliche Pode-se chegar a Algumas variáveis com bons desempenhos.

Para os testes realizados oder 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 und 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 oder de alguma outra fonte e com esse modelo realizaria as predições para cada leitura realizada.

# Codierung: utf-8

Pandas als pd importieren

numpy als np von sklearn.model_selection importieren train_test_split als tts von sklearn.neural_network importieren MLPClassifier als MLP von sklearn.metrics importieren Klassifizierung_Bericht als cr von sklearn.metrics importieren Confusion_matrix als cm. importieren

# Leitura dos dados do CSV

df = pd.read_csv('features.csv') # Trennen von Entradas 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')

# Treinando modelo

modelo.fit(X_train, Y_train) result = 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 (Prüfbericht)