Sistema Autônomo Localizador De Vazamentos: 11 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:22

Este projeto consiste em um robô, que através da leitura realizada por um dispositivo, equipado com um sensor piezoelétrico, captura os espectros das vibrações no solo, pode identifierar e localizar, com of processamento dos dados por uma rede neural, possíveis vazamentos de água ema uma tubulação.

O prosessoren gjør det mulig å realisere en algoritme for DRAGONBOARD 410c. Os dados também são enviados para um serviço na nuvem, responsável por auxiliar no processo de Integência Artificial do projeto.

Este projeto foi desenvolvido no Hackaton Qualcomm, durante a TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), participaram do projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigues, Rogério. Gomes Polo og Ronaldo P. Gomes Polo. Também participou do projeto o aluno Daniel de Castro Pacheco graduando de engenharia mecânica ved Universidade Newton Paiva de Belo Horizonte. O projeto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro og Felipe Crispim da Silva Salvagnini.

Trinn 1: Lista De Materiais

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

1 Arduino Due

1 Dragonboard 410c

2 drivere for motor de corrente continua contendo cada um:

4 Transistorer BC548

4 Diodos 1n4007

4 Motstander 4k7Ω ¼ W

1 driver for servomotor:

1 Transistores BC548

1 Diodos 1N4007

1 Motstår 4k7Ω ¼ W

1 USB -mus

1 Teclado USB

1 Skjerm

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engrenagem

1 servomotor 9g

Trinn 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, devido ao fato de se tratar de um protto tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme vídeo.

Trinn 3: Acionamento Dos Motores

Para executar a movimentação dos motores do robô ZUMO e do dispositivo de captura, fez-se necessária a montagem de dois drivers para os motores de corrente continua e um driver para o servo motor, conforme as figuras acima, sendo a primeira figura o driver para um motor de corrente continua ea segunda o driver para um servo motor.

Trinn 4: Obtenção Do Áudio

Para obtenção do espectro de áudio das vibrações do solo, foi utilizado um dispositivo desenvolvido como parte do TCC de Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro e Felipe C. da Silva Salvagnini, maiores detalhes sobre o TCC e sobrev disposit e -post [email protected].

Este dispositivo utiliza-se de um sensor piezoelétrico e uma placa de circuito que realiza a filtragem e amplificação do sinal.

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

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

Trinn 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 e needsários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada analógica poder de processamento, isso foi needsário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine installed na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui poder de processamento para essa operação.

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

Som ações konfiguradas no Arduino foram:

Realizar a aquisição dos dados;

Transmitir os dados obtidos para a DRAGONBOARD 410c;

Segue a programação:

#inkludere #definere Numb_Sample 3000 #definere DAC_Input A0

#define SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Period 60 unsigned int Scont = 0, SNow = PosServoMin; usignert lang int DAC [Numb_Sample], ind = Numb_Sample; ugyldig TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); hvis (Scont

1); // 50% driftssyklus

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

ugyldig oppsett ()

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

hulrom ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int indeks = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); switch (rc) {case 1: indeks = 0; mens (! Serial.available ()); mens ((rc = Serial.read ())! = 0xFF) {indeks << = 8; indeks += rc; mens (! Serial.available ()); } Serial.print (0); Serial.print (2); SendNumber (DAC [indeks]); Serial.print (0xFF); gå i stykker; sak 3: mens (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; forsinkelse (500); ind = 0; // TC_Start (TC1, 0); mens (ind <Numb_Sample); // TC_Stop (TC1, 0); Snø = PosServoMin; forsinkelse (500); Serial.print (0); Serial.print (4); Serial.print (0xFF); } gå i stykker; }} annet hvis (rc == '2') {Serial.print ("Test Servomotor / n"); mens (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Mode 1 / n"); SNOW = PosServoMax; } if (rc == '2') {Serial.print ("Mode 2 / n"); Snø = PosServoMin; }} */ SNow = PosServoMax; forsinkelse (100); Snø = PosServoMin; forsinkelse (100); }

Trinn 6: Interfaceamento Das Tecnologias

Para a comunicação dos dados entre o Arduíno DUE ea DRAGONBOARD 410c, inicialmente utilizou-se a interface da figura acima, o que não foi possisvel executor, então optou-se pelo uso de uma interface USB CDC entre o Arduino DUE ea DRAGONBOARD 410c, nødvenditaria da recompilação do KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

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

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

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

import timeimport seriell import pandaer som pd import numpy som np

# Configuração da conexão serial

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

ser.isOpen ()

print ('Skriv inn kommandoene nedenfor. / r / nSett inn "exit" for å forlate programmet.')

input = 1

mens 1: input = input (">>") if input == 'exit': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comando para o Arduino DUE realizar a coleta dos dados ser.write (1) # Envia o comando para o Arduino DUE transmitir os dados coletados

lista =

for jeg i rekkevidde (3000):

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

Trinn 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez nødvendária a conversão dos arquivos no formato WAV, fornecidos pelos alunos autores do TCC e colaboradores do projeto, para valores numéricos, que são utilizados nos algoritcos de análise. Para realizar esta conversão foi escrito um algoritmo em PYTHON 3 que lies or arquivo WAV e salva us dados do espectro em um arquivo CSV. O algoritmo utilizado segue abaixo e em anexo for download.

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

# koding: utf-8

# Leitura e conversão dos audio for csv

# MÓDULOS 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 (filnavn): 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') Tid = 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) returner df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

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

# GRÁFICO DO ESPECTRO DE AUDIO

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

Trinn 9: Análise Visual Do Sinal

Com o PYTHON 3 é realizada a transformada de Fourier, este artificio matemático realiza a transformação do sinal do domínio do tempo para o domínio da frequência, onde se torna possível analyse as varias frequências, and suas amplitudes, que compõem aquele sinal. Pela análise visual do gráfico da transformada de Fourier um profissional com conhecimentos específicos poderá identifierar a existência de algum vazamento na tubulação. Estes gráficos servirão para validação das análises realizadas pelo algoritmo de detecção automática.

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

# koding: utf-8# Modulos utilizados para processamento da transformada de Fourier

import pandas as pd import numpy as np import wave from matplotlib import pyplot as plt# Função que realiza a transformada de Fourier e plota os gráficos para análise def Fourier (df_list): Fs = 44100; # Taxa de amostragem em Hz Ts = 1.0/Fs; # Intervalo de amostragem y = pd.concat (df_list) t = y ['time'] # Vetor de tempos y = y ['amp'] # Vetor de amplitudes n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [område (n // 2)] Y = np.fft.fft (y)/n Y = Y [område (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) fig, ax = plt.subplots (2, 1, figsize = (20, 10)) ax [0]. plot (t, y) ax [0].set_xlabel ('Time') ax [0].set_ylabel ('Amplitude') ax [1]. Plot (frq, abs (Y), 'r') ax [1].set_xlim ([100, 800]) ax [1].set_ylim ([0, max_lim]) ax [1].set_xlabel ('Freq (Hz)') ax [1].set_ylabel ('| Y (freq) |') plt.show () return frq, abs (Y)# Função que realiza a carga dos dados do CSV and chama a função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (file_name + '.csv') df.columns = ['amp', ' time '] delta = final-init if init*44100> len (df) or final*44100> len (df): init = (len (df)/44100) -delta if init = 100) & (df [' freq '] <= 800)] mx = sortert (df [' amp ']) print ("Média das amplitudes:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") print ("100 maiores amplitudes", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplituder:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplituder:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maior amplitude:", np.mean (mx [-1:]) // df ['amp']. mean ()*100, " %", sep =" ") read_csv ('Solo_com_Vazamento', 2, 10) # Exemplo de gráficos para vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Exemplo de gráficos para sem vazamento

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

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

Este primeiro algoritmo realiza uma extração identifierada, onde é needsário saber se o arquivo de áudio trata-se de uma amostra vazamento detectado ou não, isso por que us dados resultantes desse processo servirão para o trainamento da rede neural utilizada.

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

Estas features ou caraterísticas são propriedades acústicas compostas por varias informações referentes ao espectro de áudio capturado, abaixo seguirá uma descrição (em inglês) destas características.

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

Programvare som kan brukes til å bruke algoritmer for å laste ned og tolke R Studio Studio.

Ekstra egenskaper:

• gjennomsnittlig frekvens: gjennomsnittsfrekvens (i kHz)
• sd: standardavvik for frekvens
• median: median frekvens (i kHz)
• Q25: første kvantil (i kHz)
• Q75: tredje kvantil (i kHz)
• IQR: interkvantilt område (i kHz)
• skjevhet: skjevhet (se merknad i spesifikasjonsbeskrivelse)
• kurt: kurtosis (se merknad i spesifikasjonsbeskrivelse)
• sp.ent: spektral entropi
• sfm: spektral planhet
• modus: modusfrekvens
• centroid: frekvens centroid (se spesifikasjon)
• peakf: toppfrekvens (frekvens med høyeste energi)
• meanfun: gjennomsnitt av grunnfrekvens målt over akustisk signal
• minfun: minimum grunnleggende frekvens målt på tvers av akustisk signal
• maxfun: maksimal grunnfrekvens målt over akustisk signal
• meandom: gjennomsnitt av dominerende frekvens målt på tvers av akustisk signal
• mindom: minimum av dominerende frekvens målt på tvers av akustisk signal
• maxdom: maksimal dominerende frekvens målt på tvers av akustisk signal
• dfrange: område med dominerende frekvens målt på tvers av akustisk signal
• modindx: modulasjonsindeks. Beregnet som den akkumulerte absolutte forskjellen mellom tilstøtende målinger av grunnfrekvenser dividert med frekvensområdet
• etikett: lekkasje eller uten_lekkasje

Algoritmo usado:

pakker <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'mus', 'e1071', 'rpart', 'xgboost', 'e1071') if (lengde (setdiff (pakker, rownames (installert.pakker ()))))> 0) {install.packages (setdiff (pakker, rownames (installert.pakker ()))))}

bibliotek (tuneR)

library (seewave) library (caTools) library (rpart) library (rpart.plot) library (randomForest) library (warbleR) library (mus) library (xgboost) library (e1071)

specan3 <- funksjon (X, bp = c (0, 22), wl = 2048, terskel = 5, parallell = 1) { # For å bruke parallell behandling: bibliotek (devtools), install_github ('nathanvan/parallelsugar') hvis (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 (lim inn (lim inn (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "start", "slutt") % i % kolonnenavn (X))], sammenbrudd = ","), "kolonne (r) finnes ikke i dataramme"))}} annet stopp ("X er ikke en dataramme") #hvis det er NA -er i start- eller sluttstopp hvis (noen (is.na (c (slutt, start)))) stopp ("NA -er funnet i start og/eller slutt") #if slutten eller start er ikke numerisk stopp if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' and 'selec' must be numeric") #if any start higher than end stop if (any (end - start <0)) stop (paste ("Starten er høyere enn en d i ", lengde (som (slutt - start20)) stopp (lim inn (lengde (som (slutt - start> 20))," utvalg (er) lengre enn 20 sek ")) alternativer (show.error.messages = TRUE) #hvis bp ikke er vektor eller lengde! = 2 stopp hvis (! er. vektor (bp)) stopp ("'bp' må være en numerisk vektor med lengde 2") annet {if (! length (bp) == 2) stop ("'bp' må være en numerisk vektor med lengde 2")} #return-advarsel hvis ikke alle lydfiler ble funnet fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (length (unique (sound.files [(sound.files % in % fs)]))! = length (unique (sound.files))) cat (paste (length (unique (sound. filer))-lengde (unik (lyd.filer [(lyd.filer % i % fs)])), ".wav-fil (er) ikke funnet")) #antall lydfiler i arbeidskatalogen og hvis 0 stopper d <- which (sound.files % in % fs) if (length (d) == 0) {stop (".wav-filene er ikke i arbeidskatalogen")} else {start <- start [d] end <- ende [d] selec <- selec [d] lyd.filer <- lyd.filer [d]} # Hvis parallell ikke er numerisk hvis (! er. numerisk (parallell)) stopp ("'parallell' må være en numerisk vektor med lengde 1 ") hvis (noen (! (parallell %% 1 == 0), parallell 1) {alternativer (advarsel = -1) hvis (alle (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", stille = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) else if (Sys.info () [1] == "Windows") {cat ("Windows-brukere må installere pakken 'parallelsugar' for parallell databehandling (du gjør det ikke nå!)") Lapp <- pbapply:: pblapply} else lapp <- funksjon (X, FUN) parallel:: mclapply (X, FUN, mc.cores = parallel)} else lapp <- pbapply:: pblapply alternativer (advarsel = 0) if (parallel == 1) cat ("Måling av akustiske parametere:") x <- as.data.frame (lapp (1: length (start), function (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), from = start , til = slutt , enheter = "sekunder") b tak ([email protected]/2000) - 1) b [2] < - tak ([email protected]/2000) - 1 #frekvensspekteranalyse 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 <- analyse $ gjennomsnitt/1000 sd <- analyse $ sd/1000 median <- analyse $ median/1000 Q25 < - analyse $ QQ75 <- analyse $ QIQR <- analyse $ IQR/1000 skjevhet <- analyse $ skjevhet kurt <- analyse $ kurtosis sp.ent <- analyse $ sh sfm <- analyse $ sfm modus <- analyse $ mode/1000 centroid <- analyse $ cent/1000 #Frekvens med amplitude topper peakf <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Grunnleggende frekvensparametere ff <- seewave:: fund (r, f = [email protected], ovlp = 50, terskel = terskel, 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) #Dominerende frekuensparametere y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, terskel = terskel, båndpass = b * 1000, fftw = TRUE) [, 2] meandom <- gjennomsnitt (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) varighet <- (slutt - start ) #moduleringsindeksberegning endres <- vektor () for (j der (! er. na (y))) {endring <- abs (y [j]- y [j + 1]) endringer <- vedlegg (endringer, endring)} hvis (mindom == maxdom) modindx <-0 annet modindx <- gjennomsnitt (endringer, na.rm = T)/dfrange #save results return (c (varighet, gjennomsnittlig frekvens, sd, median, Q25, Q75, IQR, skjevhet, kurt, sp.ent, sfm, modus, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #endre resultatnavn rownames (x) <- c ("varighet", "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) { # Start med tom data.frame. data <- data.frame () # Hent liste over filer i mappen. list <- list.files (mappenavn, '\. wav') # Legg til filliste i data.frame for behandling. for (filnavn i listen) {rad <- data.frame (filnavn, 0, 0, 20) data <- rbind (data, rad)} # Angi kolonnenavn. navn (data) <- c ('sound.files', 'selec', 'start', 'end') # Flytt til mappe for behandling. setwd (mappenavn) # Behandle filer. akustikk <- specan3 (data, parallell = 1) # Flytt tilbake til overordnet mappe. setwd ('..') akustikk}

kjønn <- funksjon (filePath) {hvis (! finnes ('genderBoosted')) {load ('model.bin')} # Oppsettbaner. currentPath <- getwd () fileName <- basename (filePath) path <- dirname (filePath) # Angi katalog for å lese fil. setwd (bane) # Start med tom data.frame. data <- data.frame (filnavn, 0, 0, 20) # Angi kolonnenavn. navn (data) <- c ('sound.files', 'selec', 'start', 'end') # Behandle filer. akustikk <- specan3 (data, parallell = 1) # Gjenopprett banen. setwd (currentPath) forutsi (genderCombo, newdata = akustikk)}

# Last inn data

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

# Sett etiketter.

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

# Fjern ubrukte kolonner.

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

# Fjern rader som inneholder NA -er.

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

# Skriv ut csv -datasett.

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

Trinn 11: Innløs Neural

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

En ny nevral bruk av MLP (Multilayer Perceptron), en modell som kan brukes for å identifisere en modell eller en modell for å implementere et system som gir en realistisk identifikasjon av sinal recebido, og gir informasjon om hvordan du kan gjøre det.

Foi nødvendá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 superficial pode-se chegar a algumas variáveis com bons desempenhos.

For testes realizados o modelo obteve um desempenho muito bom, alcançando na maioria dos testes uma taxa de acerto de 100%, como pode ser observado na imagem anexa.

Este algoritmo é utilizado para treinar o modelo da rede e retornar a taxa de acerto do mesmo. No sistema de detecção um algoritmo um pouco diferente seria usado, pois ele realizaria o treino ou receberia um modelo já trainado da nuvem ou de alguma outra fonte e com esse modelo realizaria as prediçõeses to cada leitura realizada.

# koding: utf-8

importer pandaer som pd

import numpy as np fra sklearn.model_selection import train_test_split som tts fra sklearn.neural_network import MLPClassifier som MLP fra sklearn.metrics importklassifisering_rapport som cr fra sklearn.metrics import confusion_matrix som cm

# Leitura dos dados do CSV

df = pd.read_csv ('features.csv') # Separação das 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 nevral

modell = MLP (alfa = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, aktivering = 'tanh', solver = 'lbfgs')

# Treinando modell

modelo.fit (X_train, Y_train) 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 (rapportere)