Sistema Autonomo Localizador De Vazamentos: 11 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:29

Este projeto Constante 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 identificar e localizar, com o processamento dos posá guamentís por uma, 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 engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Ap Lucas de Sousario Rodrigu. Gomes Polo i Ronaldo P. Gomes Polo. Uczestniczyłem w projekcie lub udziale Daniela de Castro Pacheco absolwenta 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 e Felipe Crispim da Silva Salvagnini.

Krok 1: Lista de Materiais

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

1 Arduino Due

1 Dragonboard 410c

2 Drivers para motor de corrente continua contendo cada um:

4 tranzystory BC548

4 diody 1n4007

4 rezystory 4k7Ω ¼ W

1 Sterownik do zawartości silnika serwo:

1 tranzystory BC548

1 Dioda 1N4007

1 Rezystory 4k7Ω ¼ W

1 mysz USB

1 port USB Teclado

1 monitor

1 kabel HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engenagem

1 silnik serwo 9g

Krok 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 po fato devido ao tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme video.

Krok 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 para primeira figura o um motor de corrente continua ea segunda o driver para um servo motor.

Krok 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 do sobre o dispositivo do sobre o disposicic. 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.

Jako frequências 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 freasdas das

Akwizycja é habilitada e desabilitada através da przerwanie Arduino DUE.

Krok 5: Konfiguracja Do Arduino DUE (język C)

Devido a grande quantidade de dados, niektóre 3000 pontos from the segundo, to tipo inteiro 32 bits, greados peo dispositivo de sensoriament and niezbędnych do przetwarzania algorytmów DRAGONBOARD 410c, które można wykorzystać w łatwy sposób na interfejsie użytkownika poder de processamento, isso foi necessário por que o Shield de interfaceamento Grove Seed Sensor Mezzanine instalado na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, nãoo possui poder de processamento para essa operaçãoo.

O Arduino DUE może być skonfigurowany do odbioru poleceń z platformy QUALCOMM DRAGONBOARD 410c za pośrednictwem komunikacji seryjnej.

Jak konfiguracje bez Arduino foram:

Realizar a aquisição dos dados;

Transmitir os dados obtidos na DRAGONBOARD 410c;

Przejdź programação:

#include#define Numb_Sample 3000 #define DAC_Input A0

#definiuj SERWO 7

#define PosServoMin 4 #define PosServoMax 6 #define Okres 60 unsigned int Scont=0, SNow=PosServoMin; unsigned long int DAC[Numb_Sample], ind=Numb_Sample; void TC3_Handler() { TC_GetStatus(TC1, 0); if (ind < Liczba_Próbki) DAC[ind++] = analogRead(DAC_Input); jeśli(Ciągły

1); // 50% cykl pracy

TC_SetRC(tc; kanał; rc); TC_Start(tc, kanał); tc->TC_CHANNEL[kanał]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // habilita o registradores tc->TC_CHANNEL[kanał]. TC_IDR = ~(TC_IER_CPCS | TC_IER_CPAS); // wyłączanie rejestratorów NVIC_EnableIRQ(irq); // habilita interrupção }

pusta konfiguracja ()

{ Numer seryjny.początek(115200); pinMode(DAC_Input, INPUT); TimerStart(TC1, 0, TC3_IRQn, 1500);//Uruchom licznik czasu //TC_Stop(TC1, 0); pinMode (SERWO, WYJŚCIE); }

pusta pętla()

{ /*//while(!Serial.available()); char rc;//=Serial.read(); wskaźnik int = 0; if(rc==0) { while(!Serial.available()); rc=Serial.odczyt(); switch(rc) { przypadek 1: indeks=0; while(!Serial.available()); while((rc=Serial.read())!=0xFF) { indeks <<= 8; indeks += rc; while(!Serial.available()); } Serial.print(0); Serial.print(2); WyślijNumer(DAC[indeks]); Serial.print(0xFF); przerwa; przypadek 3: while(!Serial.available()); if((Serial.read())==0xFF) { SNow=PosServoMax; opóźnienie (500); ind=0; //Początek_TC(TC1, 0); while(ind<Numb_Sample); //TC_Stop(TC1, 0); SNow=PosServoMin; opóźnienie (500); Serial.print(0); Serial.print(4); Serial.print(0xFF); } przerwa; } } else if(rc=='2') { Serial.print("Test serwosilnika\n"); while(!Serial.available()); rc=Serial.odczyt(); if(rc=='1') { Serial.print("Tryb 1\n"); ŚNow=PosServoMax; } if(rc=='2') { Serial.print("Tryb 2\n"); SNow=PosServoMin; } } */ SNow=PosServoMax; opóźnienie (100); SNow=PosServoMin; opóźnienie (100); }

Krok 6: Interfaceamento Das Tecnologias

Dla komunikacji dos dados entre o Arduíno DUE ea DRAGONBOARD 410c, inicialmente utilizou-se interfejs da figura acima, o que não foi possível executar, então optou-se ea ea de uma interface o Arduino CDC entre necessitaria da recompilação do KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

Krok 7: Konfiguracja 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 codigo abaixo.

Uwaga: 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 interfaceamento USB, co jest niezbędne do rekompilacji KERNEL na DRAGONBOARD 410c, aby uzyskać dostęp do komunikacji.

importuj czasimport seryjny importuj pandy jako pd importuj numpy jako 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.jestOtwarte()

print('Wprowadź swoje polecenia poniżej.\r\nWstaw "exit", aby opuścić aplikację.')

wejście = 1

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

lista =

dla i w zakresie (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(aual)

Krok 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 ãoo numéricos nobartilizáGON. Para realizar esta conversão foi escrito um algoritmo em PYTHON 3 que le o arquivo WAV e salva os dados zrobić espectro em um arquivo CSV. O algoritmo utilizado segue abaixo e em anexo para download.

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

# kodowanie: utf-8

# Leitura e conversão dos audios para csv

# MODULOS UTILIZADOS

import fali import numpy jako np import pandy jako pd import matplotlib.pyplot jako plt

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

def audio_to_csv(nazwa_pliku): 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) sygnał = np. fromstring(waveData, dtype='int32') Czas=np.linspace(start=0, stop=data_size/sample_rate, num=data_size, endpoint=true) df = pd.concat([pd. DataFrame(sygnał), pd. DataFrame(czas)], oś=1) df.to_csv(nazwa_pliku + '.csv', indeks=False) return df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

file_name = 'Solo_com_Vazamento' df_vazamento = audio_to_csv(nazwa_pliku) df_vazamento.columns = ['amp', 'czas'] file_name = 'Solo_sem_Vazamento' df_sem_vazamento = df_vazamento.

# 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()

Krok 9: Analiza wizualna 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 analisar as varias frequências, e suas sinal amplitudes a, Pela análise visual do gráfico da transformada de Fourier um profissional com conhecimentos específicos poderá identificar a existência de algum vazamento na tubulação. Estes graficos 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.

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

import pandy as pd import numpy as np import wave from matplotlib import pyplot as plt# Funkcja polegająca na realizacji transformacji Fouriera i wykresu wykresów analizy def Fourier(df_list): Fs = 44100; # Taxa de amostragem em Hz Ts = 1.0/Fs; # Przedział czasu y = pd.concat(df_list) t = y['czas'] # Vetor de tempos y = y['amp'] # Vetor de amplituds n = len(y) # Comprimento do sinal k = np. arange(n) T = n/Fs frq = k/T frq = frq[zakres(n//2)] Y = np.fft.fft(y)/n Y = Y[zakres(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('Czas') ax[0].set_ylabel('Amplituda') ax[1].plot(frq, abs(Y), 'r') ax[1].set_xlim([100, 800]) ax[1].set_ylim([0, max_lim]) ax[1].set_xlabel('Częst (Hz)') ax[1].set_ylabel('|Y(częst.)|') 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 if init*44100 > len(df) lub final*44100 > len(df): init = (len(df)/44100)-delta if init =100) & (df['freq ']<=800)] mx = posortowane(df['wzmacniacz']) print("Media das amplitud:", np.round(np.mean(mx))) print("Procent em relação a media das amplitud.") print("100 większych amplitud", np.mean(mx[-100:])//df['amp'].mean()*100, "%", sep="") print("50 większych amplitud:", np.mean(mx[-50:])//df ['amp'].mean()*100, "%", sep="") print("10 większych amplitud:", np.mean(mx[-10:])//df['amp']. mean()*100, "%", sep="") print("Maior amplituda:", np.mean(mx[-1:])//df['amp'].mean()*100, " %", sep="")read_csv('Solo_com_Vazamento', 2, 10) # Przykład grafiki dla vazamentoread_csv('Solo_sem_Vazamento', 2, 10) # Przykład grafiki dla wszystkich

Krok 10: Algoritmo Em R Para Extração Das zawiera Dos Dados

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

Este primeiro algoritmo realiza uma extração identificada, onde é necessário saber se o arquivo de audio trata-se de uma amostra vazamento detectado ou não, isso por que os dados resultantes desse processo servirão paratilizada treinamento da.

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

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

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

O software usado para rodar o algoritmo é gratuito, pobierz do interpretador Re do R Studio.

Características extraídas:

• meanfreq: średnia częstotliwość (w kHz)
• sd: odchylenie standardowe częstotliwości
• mediana: mediana częstotliwości (w kHz)
• Q25: pierwszy kwantyl (w kHz)
• Q75: trzeci kwantyl (w kHz)
• IQR: zakres międzykwantylowy (w kHz)
• skew: skośność (patrz uwaga w opisie specprop)
• kurt: kurtoza (patrz uwaga w opisie specprop)
• sp.ent: entropia spektralna
• sfm: płaskość widmowa
• tryb: częstotliwość trybu
• centroid: centroid częstotliwości (patrz specprop)
• peakf: częstotliwość szczytowa (częstotliwość o najwyższej energii)
• meanfun: średnia częstotliwości podstawowej mierzonej przez sygnał akustyczny
• minfun: minimalna częstotliwość podstawowa mierzona na sygnale akustycznym
• maxfun: maksymalna częstotliwość podstawowa mierzona na sygnale akustycznym
• średnia: średnia dominującej częstotliwości mierzonej w sygnale akustycznym
• mindom: minimum dominującej częstotliwości mierzonej w sygnale akustycznym
• maxdom: maksymalna dominująca częstotliwość mierzona w sygnale akustycznym
• dfrange: zakres dominującej częstotliwości mierzonej na sygnale akustycznym
• modindx: indeks modulacji. Obliczana jako skumulowana różnica bezwzględna między sąsiednimi pomiarami częstotliwości podstawowych podzielona przez zakres częstotliwości
• etykieta: przeciek lub bez przecieku

Użyte algorytmy:

pakiety <- c('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'mice', 'e1071', 'rpart', 'xgboost', 'e1071')if (length(setdiff(pakiety, nazwy wierszy(zainstalowane.pakiety()))) > 0) { install.packages(setdiff(pakiety, nazwy wierszy(zainstalowane.pakiety()))) }

biblioteka(tuneR)

biblioteka(seewave) biblioteka(caTools)biblioteka(rpart)biblioteka(rpart.plot)biblioteka(randomForest)biblioteka(warbleR)biblioteka(myszy)biblioteka(xgboost)biblioteka(e1071)

specan3 <- function(X, bp = c(0, 22), wl = 2048, próg = 5, równolegle = 1){ # Aby użyć przetwarzania równoległego: library(devtools), install_github('nathanvan/parallelsugar') if(class(X) == "data.frame") {if(all(c("sound.files", "selec", "start", "end") %in% conames(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))], collapse=", "), "nie znaleziono kolumn w ramce danych")) } else stop("X nie jest ramką danych") #jeśli na początku lub na końcu znajdują się NA, stop if(any(is.na(c(end, start)))) stop("Należy znaleźć na początku i/lub końcu") #if end lub start nie są stopem numerycznym if(all(class(end) != "numeric" & class(start) != "numeric")) stop("'end' i 'selec' muszą być numeryczne") #jeśli jakikolwiek początek jest wyższy niż koniec stop if(any(end - start<0)) stop(paste("Początek jest wyższy niż en d in", length(która(koniec - początek20)) stop(wklej(długość(która(koniec - początek>20)), "wybór(y) dłuższe niż 20 sekund")) options(show.error.messages = TRUE) #if bp nie jest wektorem ani długością!=2 stop if(!is.vector(bp)) stop("'bp' musi być wektorem numerycznym o długości 2") else{ if(!length(bp) == 2) stop("'bp' musi być wektorem numerycznym o długości 2")} #return ostrzeżenie, jeśli nie znaleziono wszystkich plików dźwiękowych fs <- list.files(path = getwd(), pattern = ".wav$", ignore.case = TRUE) if(length(unikalne(dźwięk.pliki[(dźwięk.pliki %w% fs)])) != length(unikalne(dźwięk.pliki)))) cat(wklej(długość(unikalny(dźwięk.). files))-length(unique(sound.files[(sound.files %in% fs)])), ".wav file(s) not found")) #count liczba plików dźwiękowych w katalogu roboczym i jeśli 0 stop d <- which(sound.files %in% fs) if(length(d) == 0){ stop("Pliki.wav nie znajdują się w katalogu roboczym") } else { start <- start[d] end <- end[d] selec <- selec[d] sound.files <- sound.files[d] } # Jeśli równoległość nie jest numeryczna if(!is.numeric(parallel)) stop("'parallel' musi być wektorem liczbowym o długości 1") if(any(!(parallel %% 1 == 0), równolegle 1) { options(warn = -1) if(all(Sys.info()[1] == " Windows", requireNamespace("parallelsugar", cicho = TRUE) == TRUE)) lapp <- function(X, FUN) parallelsugar::mclapply(X, FUN, mc.cores = równolegle) else if(Sys.info() [1] == "Windows"){ cat("Użytkownicy Windows muszą zainstalować pakiet 'parallelsugar' do obliczeń równoległych (nie robisz tego teraz!)") lapp <- pbapply::pblapply} else lapp <- function (X, FUN) równolegle::mclapply(X, FUN, mc.cores = równolegle)} else lapp <- pbapply::pblapply options(warn = 0) if(parallel == 1) cat("Pomiar parametrów akustycznych:") x <- as.data.frame(lapp(1:length(start), function(i) { r <- tuneR::readWave(file.path(getwd(), sound.files), from = początek, to = koniec, jednostki = "sekundy") b pułap([email protected]/2000) - 1) b[2] <- pułap([email protected]/2000) - 1 # analiza widma częstotliwości songspec <- seewave::spec(r, f = [email protected], wykres = FAŁSZ) analiza <- seewave::specprop(songspec, f = [email protected], flim = c(0, 280/1000), wykres = FALSE) #zapisz parametry meanfreq <- analiza$mean/1000 sd <- analiza$sd/1000 mediana <- analiza$median/1000 Q25 < - analiza$QQ75 <- analiza$QIQR <- analiza$IQR/1000 skos <- analiza$skośność kurt <- analiza$kurtosis sp.ent <- analiza$sh sfm <- analiza$sfm tryb <- analiza$mode/1000 centroid <- analiza$cent/1000 #Częstotliwość ze szczytami amplitudyf <-0#seewave::fpeaks(songspec, f = [email protected], wl = wl, nmax = 3, wykres = FAŁSZ)[1, 1] #Podstawowe parametry częstotliwości ff <- seewave::fund(r, f = [email protected], ovlp = 50, próg = próg, 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) #Dominujące parametry częstotliwości y <- seewave::dfreq(r, f = [email protected], wl = wl, ylim=c(0, 280/1000), ovlp = 0, plot = F, próg = próg, przepustowość = b * 1000, fftw = PRAWDA)[, 2] średnia <- średnia(y, na.rm = PRAWDA) umysł <- min(y, na.rm = PRAWDA) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom - mindom) czas trwania <- (end - start) #zmiany obliczania indeksu modulacji <- vector() for(j w którym(!jest. na(y))){ zmiana <- abs(y[j] - y[j + 1]) zmiany <- append(zmiany, zmiana) } if(mindom==maxdom) modindx<-0 else modindx <- średnia (changes, na.rm = T)/dfrange #zapisz wyniki 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)) })) #zmień nazwy wyników 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(nazwa_folderu) { # Zacznij od pustej ramki data.frame. data <- data.frame() # Pobierz listę plików w folderze. list <- list.files(folderName, '\.wav') # Dodaj listę plików do data.frame do przetworzenia. for (nazwa_pliku na liście) { wiersz <- data.frame(nazwa_pliku, 0, 0, 20) data <- rbind(dane, wiersz) } # Ustaw nazwy kolumn. names(data) <- c('sound.files', 'selec', 'start', 'end') # Przenieś do folderu w celu przetworzenia. setwd(nazwa_folderu) # Przetwarzaj pliki. akustyka <- specan3(dane, równolegle=1) # Przejdź z powrotem do folderu nadrzędnego. setwd('..') akustyka }

płeć <- function(filePath) { if (!exists('genderBoosted')) { load('model.bin') } # Ścieżki konfiguracji. currentPath <- getwd() fileName <- basename(filePath) path <- dirname(filePath) # Ustaw katalog do odczytu pliku. setwd(ścieżka) # Zacznij od pustego data.frame. data <- data.frame(nazwa_pliku, 0, 0, 20) # Ustaw nazwy kolumn. names(data) <- c('sound.files', 'selec', 'start', 'end') # Przetwarzaj pliki. akustyka <- specan3(dane, równolegle=1) # Ścieżka odtwarzania. setwd(currentPath) przewidywanie(genderCombo, newdata=acoustics) }

# Załaduj dane

wyciek <- processFolder('caminho para o makaron com próbki audio com vazamento') without_leakage <- processFolder('caminho para o makaron com próbki audio sem vazamento')

# Ustaw etykiety.

wyciek$label <- 1 without_leakage$label <- 2 dane <- rbind(wyciek, bez_wycieku) data$label <- factor(data$label, label=c('wyciek', 'bez_wycieku'))

# Usuń nieużywane kolumny.

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

# Usuń wiersze zawierające NA.

dane <- dane[kompletne.przypadki(dane),]

# Wypisz zbiór danych csv.

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

Krok 11: Ponów neuronowe

Pomysł na uso de uma rede neural, czyli 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 treinamento o modelo implantado no sistema conseguirá realizar a identificação o

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 powierzchowne 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. 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 ou de alguma outra fonte e com esse modelo realizaria as predições real paraiz cada lei.

# kodowanie: utf-8

importuj pandy jako PD

importuj numpy jako np. ze sklearn.model_selection importuj train_test_split jako tts ze sklearn.neural_network importuj MLPClassifier jako MLP ze sklearn.metrics importuj Classification_report jako cr ze sklearn.metrics importuj pomyłkę_macierz jako cm

# Leitura dos dados do CSV

df = pd.read_csv('features.csv') # Oddzielenie od wejścia df_X = df[df.columns[:len(df.columns)-1] # Filtrando jako 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, aktywacja='tanh', solver='lbfgs')

# Model Treinando

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

# Imprimindo wyników

report = cr(Y_test, wynik) mat = cm(y_pred=wynik, y_true=Y_test) print("Matryca niezrozumienia") print(mat, end="\n\n") print("Relacja klasyfikacji") print (raport)