Sistema Autônomo Localizador De Vazamentos: 11 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:08

Este projeto terdiri daripada em 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 localizar, com o processamento dos dados por uma rede neural, possíveis vazamentos 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 proseso de Integência Artificial do projeto.

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

Langkah 1: Lista De Materiais

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

1 Arduino Berakhir

1 Papan Naga 410c

2 Pemacu untuk motor de corente contua contendo cada um:

4 Transistor BC548

4 Diodos 1n4007

4 Resistores 4k7Ω ¼ W

1 Contendo motor untuk servo motor:

1 Transistor BC548

1 Diodos 1N4007

1 Resistores 4k7Ω ¼ W

1 Tetikus USB

1 Teclado USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engrenagem

1 motor servo 9g

Langkah 2: Adaptação Mecânica

Para a Aquisição dos dados pelo sensor piezoelétrico, faz se requário, o desenvolvimento de um dispositivo com pinhão e cremalheira, confe desenhos anexados, neste caso as peças foram fabricadas por uma improra 3D, devido ao fato de se tratar de um tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, confe vídeo.

Langkah 3: Acionamento Dos Motores

Para pelaksana pemacu pergerakan motor melakukan robo ZUMO e do dispositivo de captura, fez-se Needária a montagem de dois driver para os motores de corente contua e um driver untuk o servo motor, sesuai dengan figuras acima, sendo a primeira figura o driver para um motor de corente contua ea segunda o driver untuk um servo motor.

Langkah 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 Tobs sobre sobre sobre sobre sobre sobre sobre sobre sobre sobre sobre sobre sobre sobre socre e-mel [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.

Sebagaimana frekuensi interesse para o projeto estão entre 100Hz e 800Hz. Para Isso o dispositivo de sensoriamento foi configurado com uma freência de amostragem de 3 kHz para que sejam respeitada sebagai syarat melakukan teorema de amostragem de Nyquist, on a a freência de aquisição deve estar pelo menos duas vezes acas das frees.

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

Langkah 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 bit, gerados pelo dispositivo de sensoriamento e requários para processamento dos algoritmos na DRAGONBOARD 410c, juga digunakan untuk Arduino DUE untuk fazer uso de uma entrada analógica com poder de processamento, isso foi requário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine instalado na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui poder de processamento para essa operação.

O Arduino DUE juga telah mengatur konfigurasi untuk penerima os comandos enviados da plataforma QUALCOMM DRAGONBOARD 410c melalui serial comunicação.

Sebagai ações configuradas no Arduino foram:

Merealisasikan aquisição dos dados;

Transmitir os dados obtidos para DRAGONBOARD 410c;

Pilih programação:

# sertakan # tentukan Numb_Sampel 3000 #tentukan DAC_Input A0

#tentukan SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Tempoh 60 unsigned int Scont = 0, SNow = PosServoMin; DAC int panjang yang tidak ditandatangani [Numb_Sample], ind = Numb_Sample; batal TC3_Handler () {TC_GetStatus (TC1, 0); jika (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); sekiranya (Scont

1); // 50% kitaran tugas

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

persediaan tidak sah ()

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

gelung kosong ()

{/ * // sementara (! Serial.available ()); char rc; // = Serial.read (); int indice = 0; jika (rc == 0) {sementara (! Serial.available ()); rc = Serial.read (); suis (rc) {kes 1: indice = 0; sementara (! bersiri. tersedia ()); sementara ((rc = Serial.read ())! = 0xFF) {indice << = 8; indeks + = rc; sementara (! bersiri. tersedia ()); } Cetakan bersiri (0); Cetakan bersiri (2); SendNumber (DAC [indeks]); Serial.print (0xFF); rehat; kes 3: sementara (! Serial.available ()); jika ((Serial.read ()) == 0xFF) {SNow = PosServoMax; kelewatan (500); ind = 0; // TC_Start (TC1, 0); sementara (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; kelewatan (500); Cetakan bersiri (0); Cetakan bersiri (4); Serial.print (0xFF); } rehat; }} lain jika (rc == '2') {Serial.print ("Test Servo Motor / n"); sementara (! bersiri. tersedia ()); rc = Serial.read (); jika (rc == '1') {Serial.print ("Mode 1 / n"); SNow = PosServoMax; } jika (rc == '2') {Serial.print ("Mode 2 / n"); SNow = PosServoMin; }} * / SNow = PosServoMax; kelewatan (100); SNow = PosServoMin; kelewatan (100); }

Langkah 6: Interfaceamento Das Tecnologias

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

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

Foi configurada 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: 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. Oleh penerbitan opto-se pelo interfaceamento USB, que requitaria da recompilação do KERNEL na DRAGONBOARD 410c para que a porta fosse criada corretamente para a comunicação.

import timeimport siri import panda sebagai pd import numpy sebagai np

# Siri Configuração da conexão

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

ser.isBuka ()

cetak ('Masukkan perintah anda di bawah. / r / nSisipkan "exit" untuk meninggalkan aplikasi.')

input = 1

manakala 1: input = input (">>") jika 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 =

untuk i dalam jarak (3000):

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

Langkah 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez mustária a talkã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 algorosmososos. Para realizar esta chatão juga escrito um algoritmo em PYTHON 3 que lê o arquivo WAV e salva os dados do espectro em um arquivo CSV. O algoritmo utilizado segue abaixo e em anexo untuk muat turun.

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

# pengekodan: utf-8

# Leitura e percakapan dos audios para csv

# MÓDULOS UTILIZADOS

import gelombang import numpy sebagai np import panda sebagai pd import matplotlib.pyplot sebagai 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_frame) 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) kembali 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_csv (file_name '

# GRÁFICO DO ESPECTRO DE AUDIO

rajah, (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]) angka.tight_layout (h_pad = 5) plt.show ()

Langkah 9: Análise Visual Do Sinal

Komen PYTHON 3 adalah 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 freência, onde se torna possível analisar sebagai varias freências, e suas amplitude, que compõem aquele sinal. Pelbagai anfalise visual do gráfico da transformada de Fourier um profissional com conhecimentos específicos poderá identifikar sebagai wujudnya 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 freências entre 100Hz e 800Hz, fica claro a υπάρχον ncia de vazamentos quando se observam distúrbios nesse range de frekncias.

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

import panda sebagai pd import numpy sebagai gelombang import np dari matplotlib import pyplot sebagai 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 amplitudo 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 [julat (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) ara, 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 e chama a função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (file_name + '.csv') df.columns = ['amp', ' time '] delta = final-init jika init * 44100> len (df) atau final * 44100> len (df): init = (len (df) / 44100) -delta if init = 100) & (df [' freq '] <= 800)] mx = disusun (df [' amp ']) cetak ("Média das amplitude:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudo.") cetak ("100 maiores amplitudo", np.mean (mx [-100:]) // df ['amp']. mean () * 100, "%", sep = "") print ("50 maiores amplitudo:", np.mean (mx [-50:]) // df ['amp']. mean () * 100, "%", sep = "") print ("10 maiores amplitudo:", 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

Langkah 10: Algoritmo Em R Para Extração Das Mempunyai Dos Dados

Utilizou-se um algoritm 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 é requário saber se o arquivo de áudio trata-se de uma amostra vazamento Detectado ou não, penerbitannya dados resultantes desse processo servirão para o treinamento da rede neural utilizada.

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

Ciri-ciri Estas 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 juga mempunyai modifikasi untuk para atender sebagai spesifik yang melakukan projeto.

O perisian usado para rodar o algoritmo é gratuito, muat turun do interpretador R e do R Studio.

Karakteristik tambahan:

• meanfreq: frekuensi min (dalam kHz)
• sd: sisihan piawai frekuensi
• median: frekuensi median (dalam kHz)
• Q25: kuantil pertama (dalam kHz)
• Q75: kuantil ketiga (dalam kHz)
• IQR: julat interquantile (dalam kHz)
• skew: skewness (lihat catatan dalam keterangan specprop)
• kurt: kurtosis (lihat nota dalam keterangan specprop)
• sp.ent: entropi spektrum
• sfm: kerataan spektrum
• mod: frekuensi mod
• centroid: centroid frekuensi (lihat specprop)
• puncakf: frekuensi puncak (frekuensi dengan tenaga tertinggi)
• meanfun: purata frekuensi asas yang diukur merentasi isyarat akustik
• minfun: frekuensi asas minimum yang diukur merentasi isyarat akustik
• maxfun: frekuensi asas maksimum diukur pada isyarat akustik
• meandom: purata frekuensi dominan diukur pada isyarat akustik
• mindom: minimum frekuensi dominan yang diukur pada isyarat akustik
• maxdom: maksimum frekuensi dominan yang diukur pada isyarat akustik
• dfrange: julat frekuensi dominan yang diukur pada isyarat akustik
• modindx: indeks modulasi. Dikira sebagai perbezaan mutlak terkumpul antara pengukuran bersebelahan frekuensi asas yang dibahagi dengan julat frekuensi
• label: kebocoran atau tanpa_kebocoran

Algoritmo usado:

pakej <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'mice', 'e1071', 'rpart', 'xgboost', 'e1071') jika (panjang (setdiff (pakej, nama rown (install.packages ())))> 0) {install.packages (setdiff (paket, rownames (install.packages ())))}

perpustakaan (tuneR)

perpustakaan (gelombang laut) perpustakaan (caTools) perpustakaan (rpart) perpustakaan (rpart.plot) perpustakaan (randomForest) perpustakaan (warbleR) perpustakaan (tikus) perpustakaan (xgboost) perpustakaan (e1071)

specan3 <- fungsi (X, bp = c (0, 22), wl = 2048, ambang = 5, selari = 1) {# Untuk menggunakan pemprosesan selari: perpustakaan (devtools), install_github ('nathanvan / parallelsugar') jika (class (X) == "data.frame") {if (semua (c ("sound.files", "selec", "start", "end")% in% colnames (X))) {mula <- as.numeric (unlist (X $ start)) end <- as.numeric (unlist (X $ end)) sound.files <- as.character (unlist (X $ sound.files)) selek <- as.character (unlist (X $ selec))} lain berhenti (paste (tampal (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "start", "end")% in% colnames (X))], collapse = ","), "column (s) tidak dijumpai dalam bingkai data"))} lain berhenti ("X bukan kerangka data" #jika terdapat NA di awal atau akhir berhenti jika (ada (is.na (c (akhir, mula)))) berhenti ("NAs terdapat di awal dan / atau akhir") #jika akhir atau permulaan bukan angka berhenti if (all (class (end)! = "numeric" & class (start)! = "numeric")) berhenti ("'end' dan 'selec' mesti berangka") #jika ada permulaan yang lebih tinggi daripada penghentian akhir jika (sebarang (akhir - mula <0)) berhenti (tampal ("Permulaan lebih tinggi daripada en d in ", length (yang (akhir - mula20)) berhenti (tampal (panjang (yang (akhir - mula> 20))," pilihan lebih dari 20 saat ")) pilihan (show.error.messages = TRUE #if bp bukan vektor atau panjang! = 2 berhenti jika (! is.vector (bp)) berhenti ("'bp' mestilah vektor berangka panjang 2") yang lain {if (! length (bp) == 2) stop ("'bp' mestilah vektor berangka panjang 2")} #peringatan jika tidak semua fail bunyi dijumpai fs <- list.files (path = getwd (), pattern = ".wav $", abaikan.case = BENAR) jika (panjang (unik (sound.files [(sound.files% in% fs)]))! = panjang (unik (sound.files))) kucing (tampal (panjang (unik (suara) fail)) - panjang (unik (sound.files [(sound.files% in% fs)])), ".wav file tidak dijumpai")) #jumlah bilangan fail suara dalam direktori kerja dan jika 0 berhenti d <- yang (sound.files% in% fs) if (length (d) == 0) {stop ("Fail.wav tidak ada di direktori yang berfungsi")} lain {start <- start [d] end <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Jika selari tidak berangka jika (! is.numeric (parallel)) berhenti ("'parallel' must jadikan vektor berangka panjang 1 ") jika (ada (! (selari %% 1 == 0), selari 1) {pilihan (amaran = -1) jika (semua (Sys.info () [1] ==" Windows ", memerlukanNamespace (" parallelsugar ", diam = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) lain jika (Sys.info () [1] == "Windows") {cat ("Pengguna Windows perlu memasang pakej 'parallelsugar' untuk pengkomputeran selari (anda tidak melakukannya sekarang!)") Lapp <- pbapply:: pblapply} other lapp <- function (X, FUN) selari:: mclapply (X, FUN, mc.cores = parallel)} other lapp <- pbapply:: pblapply options (warn = 0) if (parallel == 1) cat ("Mengukur parameter akustik:") x <- as.data.frame (lapp (1: length (start), function (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), dari = mulai , hingga = akhir , unit = "saat") b siling ([email protected]/2000) - 1) b [2] <- siling ([email protected]/2000) - 1 #frequency spektrum analysis songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analisis <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #simpan parameter meanfreq <- analisis $ min / 1000 sd <- analisis $ sd / 1000 median <- analisis $ median / 1000 Q25 < - analisis $ QQ75 <- analisis $ QIQR <- analisis $ IQR / 1000 skew <- analisis $ skewness kurt <- analisis $ kurtosis sp.ent <- analisis $ sh sfm <- analisis $ sfm mod <- analisis $ mod / 1000 centroid <- analisis $ cent / 1000 #Frequency with amplitude puncak puncakf <- 0 # seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] # Parameter frekuensi asas ff <- gelombang laut:: dana (r, f = [email protected], ovlp = 50, ambang = ambang, fmax = 280, ylim = c (0, 280/1000), plot = SALAH, wl = wl) [, 2] meanfun <-mean (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) # Parameter frekuensi frekuensi y <- gelombang laut:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, ambang = ambang, jalur lebar = b * 1000, fftw = BENAR) [, 2] meandom <- mean (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom - mindom) durasi <- (end - start ) # pengiraan indeks modulasi berubah <- vektor () untuk (j di mana (! is. na (y))) {perubahan <- abs (y [j] - y [j + 1]) perubahan <- append (perubahan, perubahan)} jika (mindom == maxdom) modindx <-0 lain modindx <- mean (perubahan, na.rm = T) / dfrange #save hasil kembali (c (tempoh, meanfreq, sd, median, Q25, Q75, IQR, skew, kurt, sp.ent, sfm, mode, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #tukar nama nama nama baris (x) <- c ("tempoh", "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))) nama panggilan (x) [1: 2] <- c ("sound.files", "selec") nama baris (x) <- c (1: nrow (x)) return (x)}

processFolder <- function (folderName) {# Mulakan dengan data.frame kosong. data <- data.frame () # Dapatkan senarai fail dalam folder. list <- list.files (folderName, '\. wav') # Tambahkan senarai fail ke data.frame untuk diproses. untuk (nama file dalam senarai) {baris <- data.frame (nama file, 0, 0, 20) data <- rbind (data, baris)} # Tetapkan nama lajur. nama (data) <- c ('sound.files', 'selec', 'start', 'end') # Pindah ke folder untuk diproses. setwd (folderName) # Memproses fail. akustik <- specan3 (data, parallel = 1) # Pindah kembali ke folder induk. setwd ('..') akustik}

gender <- function (filePath) {if (! wujud ('genderBoosted')) {load ('model.bin')} # Laluan persediaan. currentPath <- getwd () fileName <- basename (filePath) path <- dirname (filePath) # Tetapkan direktori untuk membaca fail. setwd (jalan) # Mulakan dengan data.frame kosong. data <- data.frame (nama file, 0, 0, 20) # Tetapkan nama lajur. nama (data) <- c ('sound.files', 'selec', 'start', 'end') # Proses fail. akustik <- specan3 (data, parallel = 1) # Pulihkan jalan. setwd (currentPath) meramalkan (genderCombo, newdata = akustik)}

# Muatkan data

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

# Tetapkan label.

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

# Keluarkan lajur yang tidak digunakan.

data $ durasi <- NULL data $ sound.files <- NULL data $ selec <- NULL data $ puncakf <- NULL

# Keluarkan baris yang mengandungi NA.

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

# Tulis set data csv.

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

Langkah 11: Rede Neural

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

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

Foi mustá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 juga realizado nenhuma abordagem estatística muito aprofundada, mas mesmo com um trabalho mais superficial pode-se chegar a algumas variáveis com bons desempenhos.

Para os testes realizados o modelo obteve um desempenho muito bom, alcançando na maioria dos testes uma taxa 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. Tiada sistema de detecção um algoritmo um pouco diferente seria usado, pois ele realizaria o treino ou receberia um modelo já treinado da nuvem ou de alguma outra fonte e com esse modelo realizaria sebagai prasyarat para cada leitura realizada.

# pengekodan: utf-8

import panda sebagai pd

import numpy sebagai np dari sklearn.model_selection import train_test_split sebagai tts dari sklearn.neural_network import MLPClassifier sebagai MLP dari sklearn.metrik import classification_report as cr from sklearn.metrics import confusion_matrix sebagai cm

# Leitura dos dados melakukan 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 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) hasil = modelo.predict (X_test)

# Hasil imprimindo

laporan = cr (Y_test, hasil) tikar = cm (y_pred = hasil, y_true = Y_test) cetakan ("Matriz de confusão") cetakan (tikar, akhir = "\ n / n") cetakan ("Relatório de Classificação") cetakan (laporan)