Sistema Autônomo Localizador De Vazamentos: 11 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

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 o processamento dos dados por uma rede neural, possíveis vazamentos de água em uma tubulação.

O processamento destes dados é realizado por algoritmos installal 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 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 på 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.

Trin 1: Lista De Materiais

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

1 Arduino Due

1 Dragonboard 410c

2 drivere til motor de corrente continua contendo cada um:

4 Transistores BC548

4 Diodos 1n4007

4 Modstande 4k7Ω ¼ W

1 Driver til servomotor:

1 Transistores BC548

1 Diodos 1N4007

1 Modstår 4k7Ω ¼ W

1 USB -mus

1 Teclado USB

1 Skærm

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engrenagem

1 servomotor 9g

Trin 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, next caso as peças foram fabricadas por uma impressionora 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.

Trin 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.

Trin 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 dispositions e -mail [email protected].

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

Som frekvenser af 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.

Trin 5: Configuração Do Arduino DUE (sprog C)

Devido a grande quantidade de dados, cerca de 3000 pontos por segundo, do tipo inteiro de 32 bits, gerados pelo dispositivo de sensoriamento and 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 on 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 us comandos enviados da plataforma QUALCOMM DRAGONBOARD 410c via comunicação serial.

Som ações konfiguradas ingen 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 #define DAC_Input A0

#define SERVO 7

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

1); // 50% driftscyklus

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 opsætning ()

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

hulrum ()

{/*// 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); pause; sag 3: mens (! Serial.available ()); hvis ((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); } pause; }} ellers hvis (rc == '2') {Serial.print ("Test Servomotor / n"); mens (! Serial.available ()); rc = Serial.read (); hvis (rc == '1') {Serial.print ("Mode 1 / n"); SNow = PosServoMax; } hvis (rc == '2') {Serial.print ("Tilstand 2 / n"); SN = PosServoMin; }} */ SNow = PosServoMax; forsinkelse (100); SN = PosServoMin; forsinkelse (100); }

Trin 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 executar, 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.

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

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

Bemærk: 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. Por isso 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 seriel import pandaer som pd import numpy som np

# Configuração da conexão seriel

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

ser.isOpen ()

print ('Indtast dine kommandoer herunder. / r / nIndsæt "exit" for at forlade programmet.')

input = 1

mens 1: input = input (">>") hvis 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 i inden for rækkevidde (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)

Trin 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez necessária a conversão dos arquivos no formato WAV, fornecidos pelos alunos autores do TCC e colaboradores do projeto, para valores numéricos, que são utilizados nos algoritcos de análise. Para realizar esta conversão foi escrito um algoritmo em PYTHON 3 que lies of arquivo WAV e salva os dados do espectro em um arquivo CSV. O algoritmo utilizado segue abaixo e em anexo for 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.

# kodning: utf-8

# Leitura e conversão dos audio til csv

# MÓDULOS UTILIZADOS

importbølge import numpy som np importpandaer som pd import matplotlib.pyplot som 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 (filnavn + '.csv', index = Falsk) returner df

# CARREGANDO DATA FRAME COM OS DADOS GØR LYD

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 GØR 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 ()

Trin 9: Analiser 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 disturbios nesse range de frequências.

# kodning: UTF-8# Modulos utilizados para processamento da transformada de Fourier

import pandaer som pd import numpy som np import bølge fra matplotlib import pyplot som 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 = sorteret (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 amplituder", 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

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

Udnyttelse af algoritme i forbindelse med realisering af processer og ekstra funktioner i egenskaber (karakteristika).

Este primeiro algoritmo realiza uma extração identificada, 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 systemema 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 identificaçã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.

O software, der bruges til at bruge en algoritme til gratis, kan du downloade tolkningen af R Studio.

Ekstra egenskaber:

• middelfrekvens: middelfrekvens (i kHz)
• sd: standardafvigelse af frekvens
• median: medianfrekvens (i kHz)
• Q25: første kvantil (i kHz)
• Q75: tredje kvantil (i kHz)
• IQR: interkvantilt område (i kHz)
• skævhed: skævhed (se note i specprop -beskrivelse)
• kurt: kurtosis (se note i specprop beskrivelse)
• sp.ent: spektral entropi
• sfm: spektral fladhed
• tilstand: tilstandsfrekvens
• centroid: frekvens centroid (se specprop)
• peakf: spidsfrekvens (frekvens med højeste energi)
• meanfun: gennemsnit af grundfrekvens målt på tværs af akustisk signal
• minfun: minimum grundlæggende frekvens målt på tværs af akustisk signal
• maxfun: maksimal grundfrekvens målt på tværs af akustisk signal
• meandom: gennemsnit af dominerende frekvens målt på tværs af akustisk signal
• mindom: minimum dominerende frekvens målt på tværs af akustisk signal
• maxdom: maksimal dominerende frekvens målt på tværs af akustisk signal
• dfrange: rækkevidde af dominerende frekvens målt på tværs af akustisk signal
• modindx: modulationsindeks. Beregnet som den akkumulerede absolutte forskel mellem tilstødende målinger af grundfrekvenser divideret med frekvensområdet
• etiket: lækage eller uden_lækage

Algoritmo usado:

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

bibliotek (tuneR)

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

specan3 <- funktion (X, bp = c (0, 22), wl = 2048, tærskel = 5, parallel = 1) { # For at bruge parallel 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))} stop ellers (indsæt (indsæt (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "start", "slut") % i % kolonnenavne (X))], sammenbrud = ","), "kolonne (r) findes ikke i dataramme"))}} stop ellers ("X er ikke en dataramme") #hvis der er NA'er i start- eller slutstop, hvis (enhver (is.na (c (slut, start)))) stop ("NA'er fundet i start og/eller slutning") #if slut eller start ikke er numerisk stop hvis (alle (klasse (slut)! = "numerisk" & klasse (start)! = "numerisk")) stop ("'slut' og 'selec' skal være numerisk ') #hvis en start er højere end slutstop, hvis (enhver (slut - start <0)) stop (indsæt ("Starten er højere end en d i ", længde (som (slut - start20)) stop (indsæt (længde (som (slut - start> 20))," valg (r) længere end 20 sek ")) muligheder (show.error.messages = TRUE) #hvis bp ikke er vektor eller længde! = 2 stop, hvis (! er. vektor (bp)) stop ("'bp' skal være en numerisk vektor med længde 2") ellers {if (! length (bp) == 2) stop ("'bp' skal være en numerisk vektor med længde 2")} #return-advarsel, hvis ikke alle lydfiler blev fundet 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))-længde (unik (lyd.filer [(lyd.filer % i % fs)])), ".wav-fil (er) ikke fundet")) #antal lydfiler i arbejdskataloget og hvis 0 stopper d <- hvilken (sound.files % i % fs) if (length (d) == 0) {stop (".wav-filerne er ikke i arbejdskataloget")} else {start <- start [d] end <- ende [d] selec <- selec [d] sound.files <- sound.files [d]} # Hvis parallel ikke er numerisk, hvis (! er. numerisk (parallel)) stop ("'parallel' skal være en numerisk vektor med længde 1 ") hvis (nogen (! (parallel %% 1 == 0), parallel 1) {optioner (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-brugere skal installere pakken 'parallelsugar' til parallel computing (du gør det ikke nu!)") Lapp <- pbapply:: pblapply} else lapp <- funktion (X, FUN) parallel:: mclapply (X, FUN, mc.cores = parallel)} else lapp <- pbapply:: pblapply muligheder (advarsel = 0) if (parallel == 1) cat ("Måling af akustiske parametre:") x <- as.data.frame (lapp (1: length (start), function (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), from = start , til = slut , enheder = "sekunder") b loft ([email protected]/2000) - 1) b [2] < - loft ([email protected]/2000) - 1 #frekvensspektrumanalyse songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analyse <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #save parametre meanfreq <- analyse $ middel/1000 sd <- analyse $ sd/1000 median <- analyse $ median/1000 Q25 < - analyse $ QQ75 <- analyse $ QIQR <- analyse $ IQR/1000 skævhed <- analyse $ skævhed kurt <- analyse $ kurtosis sp.ent <- analyse $ sh sfm <- analyse $ sfm mode <- analyse $ mode/1000 centroid <- analyse $ cent/1000 #Frekvens med amplitude toppe peakf <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Grundlæggende frekvensparametre ff <- seewave:: fund (r, f = [email protected], ovlp = 50, tærskel = tærskel, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] middelværdi <-middel (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #dominerende frekuensparametre y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, tærskel = tærskel, båndpass = b * 1000, fftw = TRUE) [, 2] meandom <- middelværdi (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) varighed <- (slut - start ) #modulationsindeksberegning ændrer <- vektor () for (j, hvor (! er. na (y))) {ændring <- abs (y [j]- y [j + 1]) ændrer <- tilføj (ændrer, ændr)} hvis (mindom == maxdom) modindx <-0 ellers modindx <- middelværdi (ændringer, na.rm = T)/dfrange #save resultater returnerer (c (varighed, middelfrekvens, sd, median, Q25, Q75, IQR, skævhed, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #ændring af resultatnavne rownames (x) <- c ("varighed", "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 <- funktion (mappenavn) { # Start med tom data.frame. data <- data.frame () # Hent liste over filer i mappen. list <- list.files (mappenavn, '\. wav') # Føj filliste til data.ramme til behandling. for (filnavn i listen) {række <- data.frame (filnavn, 0, 0, 20) data <- rbind (data, række)} # Angiv kolonnenavne. navne (data) <- c ('sound.files', 'selec', 'start', 'end') # Flyt til mappe til behandling. setwd (mappenavn) # Behandl filer. akustik <- specan3 (data, parallel = 1) # Flyt tilbage til overordnet mappe. setwd ('..') akustik}

køn <- funktion (filePath) {hvis (! eksisterer ('genderBoosted')) {load ('model.bin')} # Opsætningsstier. currentPath <- getwd () fileName <- basename (filePath) sti <- dirname (filePath) # Indstil bibliotek til at læse fil. setwd (sti) # Start med tom data.ramme. data <- data.frame (filnavn, 0, 0, 20) # Angiv kolonnenavne. navne (data) <- c ('sound.files', 'selec', 'start', 'end') # Behandle filer. akustik <- specan3 (data, parallel = 1) # Gendan sti. setwd (currentPath) forudsige (genderCombo, newdata = akustik)}

# Indlæs data

lækage <- processFolder ('caminho para o pasta com samples de áudio com vazamento') uden_lækage <- processFolder ('caminho para o pasta com samples de áudio sem vazamento')

# Indstil etiketter.

lækage $ label <- 1 uden_lækage $ label <- 2 data <- rbind (lækage, uden_lækage) data $ label <- faktor (data $ label, labels = c ('lækage', 'uden_lækage'))

# Fjern ubrugte kolonner.

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

# Fjern rækker, der indeholder NA'er.

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

# Skriv csv -datasæt ud.

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

Trin 11: Indløs Neural

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

En ny neural udnyttelse af MLP (Multilayer Perceptron), en model for en træning med tidligere identifikationer og eksempler på, at man ikke kan implementere noget system til at identificere en automatisk identifikation af information om, hvordan man kan se, om det er muligt.

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

For os 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 system 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.

# kodning: utf-8

importer pandaer som pd

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

# Leitura dos dados gør 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 neurale

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

# Treinando modelo

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

# Imprimindo resultat

rapport = cr (Y_test, resultat) mat = cm (y_pred = resultat, y_true = Y_test) print ("Matriz de confusão") print (mat, end = "\ n / n") print ("Relatório de Classificação") print (rapport)