Sistema Autônomo Localizador De Vazamentos: 11 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:13

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 uma tubulação.

O processamento destes dados and realizado por algoritmos installs on 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), משתתף בפרוייקטו של הלימודים באנג'נה מקטרוניה Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigues, Rogério. גומס פולו ורונאלדו פ גומס פולו. Também participou do projeto o aluno Daniel de Castro Pacheco graduando de engenharia mecânica by Universidade Newton Paiva de Belo Horizonte. O projeto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, לוקאס נונס מונטיירו ופליפה קריספים דה סילבה סלבגניני.

שלב 1: Lista De Materiais

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

1 ארדואינו דו

1 דרגוןבורד 410c

2 מנהלי התקנים עבור motor de corrente continua contendo cada um:

4 טרנזיסטורים BC548

4 דיודוס 1n4007

4 נגדים 4k7Ω ¼ W

מנהל התקן אחד עבור מנוע סרוו סרוו:

1 טרנזיסטורים BC548

1 דיודוס 1N4007

1 מתנגד 4k7Ω ¼ W

1 עכבר USB

1 USB Teclado

1 צג

1 קאבו HDMI

1 רובו דה אסטיראס - פלאטופורמה זומו

1 Mini dispositivo de cremalheira e engrenagem

מנוע סרוו אחד 9 גרם

שלב 2: Adaptação Mecânica

Para a aquisição dos dados pelo sensor piezoelétrico, faz se nødvendá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 prototo tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, conforme vídeo.

שלב 3: Acionamento Dos Motores

עבור מנהל תנועה של רובוטים ZUMO e do dispositivo de captura, fez-se needsária a montagem de dois drivers for os motores de corrente continua e um driver for o servo motor, conforme as figuras acima, sendo a primeira figura o driver para um motor de corrente continua ea segunda o driver for motor servo.

שלב 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 Detailshes sobre o TCC e sobre o dispositivo דוא ל [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.

כפי שתגובות העניין מעניינות את עצמנו בין 100Hz ו- 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.

שלב 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 nødvendários para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado of Arduino DUE para fazer uso de uma entrada analogica poder de processamento, isso foi needsário por que o Shield de interfaceamento Grove Seeed Sensor Mezzanine installed on DRAGONBOARD 410c, que possui on microcontrolador ATmega 328, no possuedui poder de processamento for essa operação.

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

בתור תצורות ללא ארדואינו פורם:

Realizar a aquisição dos dados;

Transmitir os dados obtidos para DRAGONBOARD 410c;

להפריד תכנית:

#כוללים #הגדר Numb_Sample 3000 #הגדר DAC_Input A0

#define SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Period 60 unsigned int Scont = 0, SNow = PosServoMin; DAC [Numb_Sample] לא חתום, ind = Numb_Sample; void TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); אם (סקונט

1); // מחזור עבודה של 50%

TC_SetRC (tc, ערוץ, rc); TC_Start (tc, ערוץ); tc-> TC_CHANNEL [ערוץ]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // habilita os registradores tc-> TC_CHANNEL [ערוץ]. TC_IDR = ~ (TC_IER_CPCS | TC_IER_CPAS); // desabilita os registradores NVIC_EnableIRQ (אירק); // habilita interrupção}

הגדרת חלל ()

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

לולאת חלל ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int indice = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); מתג (rc) {מקרה 1: מדד = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indice << = 8; מדד += rc; while (! Serial.available ()); } Serial.print (0); Serial.print (2); SendNumber (DAC [מדד]); Serial.print (0xFF); לשבור; מקרה 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNOW = PosServoMax; עיכוב (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNOW = PosServoMin; עיכוב (500); Serial.print (0); Serial.print (4); Serial.print (0xFF); } לשבור; }} else if (rc == '2') {Serial.print ("Test Servo Motor / n"); while (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("מצב 1 / n"); SNOW = PosServoMax; } if (rc == '2') {Serial.print ("מצב 2 / n"); SNOW = PosServoMin; }} */ SNow = PosServoMax; עיכוב (100); SNOW = PosServoMin; עיכוב (100); }

שלב 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 possibvel executive, então optou-se pelo uso de uma USB CDC entre or Arduino DUE ea DRAGONBOARD, nødvenditaria da recompilação do KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponível.

שלב 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.

הערה: אברדג'ם ניצול לא קודיגו, não funcionou devido aos níveis de tensão utilizados pelo Arduíno DUE e o Mezzanine serem incompatíveis. אם יש צורך בממשק USB, יש צורך לבצע recompilação של KERNEL ל- DRAGONBOARD 410c עבור קיצור קורטמנטה מקוון.

יבוא זמן ייבוא פנדות יבוא סדרתי כ- pd יבוא numpy כמו np

# סדרת 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.isOpen ()

print ('הזן את הפקודות שלך למטה. / r / n הכנס "יציאה" כדי לעזוב את היישום.')

קלט = 1

בעוד 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

רשימה =

לטווח טווח (3000):

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

שלב 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

עבור פודר מציג אומה ראשונה אנאליזה לדאדוס 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. אם אתה יכול לנהל את המסמך הזה, תוכל להשתמש ב- algoritmo ב- PYTHON 3. O algoritmo utilizado segue abaixo e em anexo for download.

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

# קידוד: utf-8

# Leitura e conversão dos audios עבור csv

# MÓDULOS UTILIZADOS

גל יבוא ייבוא numpy כמו np יבוא פנדות כמו יבוא pd matplotlib.pyplot כ plt

# FUNÇÃO PARA ממיר WAV EM DADOS DO ESPECTRO E SALVAR CSV

def audio_to_csv (שם קובץ): wave_file = wave.open (שם קובץ+'. wav', 'rb') data_size = wave_file.getnframes () sample_rate = wave_file.getframerate () time_step = 1/sample_rate waveData = wave_file.readframes (data_size -size-1) signal = np.fromstring (waveData, dtype = 'int32') Time = np.linspace (start = 0, stop = data_size/sample_rate, num = data_size, endpoint = True) df = pd.concat ([pd. DataFrame (signal), pd. DataFrame (Time)], axis = 1) df.to_csv (שם קובץ + '.csv', index = False) החזר df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

file_name = 'Solo_com_Vazamento' df_vazamento = audio_to_csv (שם קובץ) 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

איור, (ax1, ax2) = חלקות משנה (מספר = 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 ()

שלב 9: אנאליזה 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 analisar as different 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á identificar a existência de algum vazamento na tubulação. Estes gráficos servirão para validação das análises realizadas pelo algoritmo de detecção automática.

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

# קידוד: utf-8

ייבוא פנדות כ- pd יבוא numpy כמו גל ייבוא np מ- matplotlib יבוא pyplot כמו 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 [טווח (n // 2)] Y = np.fft.fft (y)/n Y = Y [טווח (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) תאנה, ax = plt. חלקות משנה (2, 1, figsize = (20, 10)) ax [0]. plot (t, y) ax [0].set_xlabel ('זמן') 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 () חזור frq, abs (Y)# Função que realiza a cargo 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 = ממוין (df [' amp ']) הדפסה ("אמפליטודות של Média das:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") הדפסה ("100 אמירות משרות", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 אמירות אמירות:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 אמירות אמירות:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("משרעת מאור:", 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

שלב 10: Algoritmo Em R Para Extração Das Features Dos Dados

שימוש באלגוריתמים עבור העדכונים והתכונות הנוספות של התכונות (características).

Este primeiro algoritmo realiza uma extração זיהוי, והכרחי זה צריך להיות או arquivo de áudio trata-se de uma amostra vazamento detectado ou não, isso por que us resultos des desses processo servirão para o trainamento da rede utilizada.

Para quando o systema 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 for atender as especificações do projeto.

תוכנת שימוש עבור תוכנת אלגוריתם בחינם, הורדה של פרשנות R e do R Studio.

תכונות características extraídas:

• ממוצע: תדר ממוצע (בקילוהרץ)
• sd: סטיית התקן של התדר
• חציון: תדירות חציונית (בקילוהרץ)
• Q25: הכמות הראשונה (בקילוהרץ)
• Q75: הכמות השלישית (בקילוהרץ)
• IQR: טווח ביניים (בקילוהרץ)
• הטייה: עקמומיות (ראו הערה בתיאור המפרט)
• קורט: קורטוזיס (ראה הערה בתיאור המפרט)
• sp.ent: אנטרופיה ספקטרלית
• sfm: שטחה ספקטרלית
• מצב: תדר מצב
• centroid: centroid תדירות (ראה specprop)
• peakf: תדירות שיא (תדירות עם האנרגיה הגבוהה ביותר)
• ממוצע: ממוצע התדר הבסיסי הנמדד על פני אות אקוסטי
• minfun: תדר יסודי מינימלי הנמדד על פני אות אקוסטי
• maxfun: תדר יסודי מרבי הנמדד על פני אות אקוסטי
• meandom: ממוצע התדר הדומיננטי הנמדד על פני אות אקוסטי
• mindom: מינימום תדר דומיננטי הנמדד על פני אות אקוסטי
• maxdom: מקסימום התדר הדומיננטי הנמדד על פני אות אקוסטי
• dfrange: טווח התדרים הדומיננטיים הנמדדים על פני אות אקוסטי
• modindx: מדד אפנון. מחושב כהפרש המוחלט המצטבר בין מדידות סמוכות של תדרי היסוד מחולק בטווח התדרים
• תווית: דליפה או ללא_דליפה

Algoritmo usado:

חבילות <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'עכברים', 'e1071', 'rpart', 'xgboost', 'e1071') אם (length (setdiff (חבילות, שמות שם (installed.packages ())))> 0) {install.packages (setdiff (חבילות, שמות rown (install.packages ())))}}

ספרייה (tuneR)

ספרייה (גלי גלי) ספרייה (caTools) ספרייה (rpart) ספרייה (rpart.plot) ספריית (randomForest) ספריית (warbleR) ספריית (עכברים) ספריית (xgboost) ספריית (e1071)

specan3 <- פונקציה (X, bp = c (0, 22), wl = 2048, סף = 5, מקביל = 1) { # כדי להשתמש בעיבוד מקביל: ספרייה (devtools), install_github ('nathanvan/parallelsugar') אם (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 אחר (הדבק (הדבק (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "התחל", "סיום") % ב % colnames (X))], collaps = ","), "העמודות אינן נמצאות במסגרת הנתונים"))} stop אחר ("X אינו מסגרת נתונים") #אם יש תעודות NA בתחנת התחלה או סיום אם (איזשהו (is.na (c (סוף, התחלה)))) עצירה ("NA נמצאו בהתחלה ו/או בסיום") #אם סיום או התחלה אינם עצירה מספרית if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' ו- 'selec' חייב להיות מספרי") #אם כל התחלה גבוהה יותר מאשר עצירת סיום אם (כל (סוף - התחל <0)) עצירה (הדבק ("ההתחלה גבוהה יותר מה- en d ב- ", אורך (אשר (סוף - התחלה 20)) עצור (הדבק (אורך (אשר (סוף - התחלה> 20))," בחירות (יותר) מ- 20 שניות ")) אפשרויות (show.error.messages = TRUE) #אם bp אינו וקטור או אורך! = 2 עצירה אם (! is.vector (bp)) stop ("'bp' חייב להיות וקטור מספרי באורך 2") אחר {if (! length (bp) == 2) stop ("'bp' חייב להיות וקטור מספרי באורך 2")} #return warning אם לא נמצאו כל קבצי הקול fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (אורך (ייחודי (sound.files [(sound.files % ב- % fs)])! = length (ייחודי (sound.files))) cat (הדבק (אורך (ייחודי (צליל. קבצים))-אורך (ייחודי (sound.files [(sound.files % ב- % fs)])), "קובצי.wav (ים) לא נמצאו")) #מספר קבצי הקול בספריית העבודה ואם 0 מפסיקים d <- which (sound.files % in % fs) if (length (d) == 0) {stop ("קובצי.wav אינם נמצאים בספריית העבודה")} else {start <- start [d] end <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # אם המקביל אינו מספרי אם (! is.numeric (במקביל)) עצור ("'מקביל' חייב להיות וקטור מספרי באורך 1 ") אם (כל (! (מקבילה %% 1 == 0), מקביל 1) {אופציות (אזהרה = -1) אם (כל (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", בשקט = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) else if (Sys.info () [1] == "Windows") {cat ("משתמשי Windows צריכים להתקין את חבילת 'parallelsugar' למחשוב מקביל (אתה לא עושה את זה עכשיו!)") Lapp <- pbapply:: pblapply} else lapp <- פונקציה (X, FUN) מקביל:: mclapply (X, FUN, mc.cores = parallel)} else lapp <- pbapply:: pblapply אפשרויות (הזהר = 0) אם (במקביל == 1) cat ("מדידת פרמטרים אקוסטיים:") x <- as.data.frame (lapp (1: length (start), function (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), מ = התחל , עד = סיום , יחידות = "שניות") תקרה b ([email protected]/2000) - 1) b [2] < - תקרה ([email protected]/2000) - 1 #frequency ניתוח ספקטרום תדרים songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) ניתוח <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #שמור פרמטרים meanfreq <- ניתוח $ ממוצע/1000 sd <- ניתוח $ sd/1000 חציון <- ניתוח $ חציון/1000 Q25 < - ניתוח $ QQ75 <- ניתוח $ QIQR <- ניתוח $ IQR/1000 הטיה <- ניתוח $ עקמת קורט <- ניתוח $ kurtosis sp.ent <- ניתוח $ sh sfm <- ניתוח $ sfm מצב <- ניתוח $ mode/1000 centroid <- ניתוח $ cent/1000 #תדירות עם שיא משרעת שיא <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #פרמטרי תדר בסיסיים ff <- seewave:: fund (r, f = [email protected], ovlp = 50, סף = סף, 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) #פרמטרים דומיננטיים בולטים y <- גלי גלישה:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, סף = סף, פס פס = b * 1000, fftw = TRUE) [, 2] meandom <- ממוצע (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) משך <- (סוף - התחל ) #חישוב מדד האפנון משתנה <- וקטור () עבור (j בו (! הוא. na (y))) {change <- abs (y [j]- y [j + 1]) שינויים <- הוספה (שינויים, שינוי)} אם (mindom == maxdom) modindx <-0 אחר modindx <- ממוצע (שינויים, na.rm = T)/dfrange #save תוצאות החזרת (c (משך, ממוצע, sd, חציון, Q25, Q75, IQR, הטיה, קורט, sp.ent, sfm, מצב, צנטרואיד, peakf, ממוצע, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #שינוי שמות תוצאות שמות שם (x) <- c ("משך", "meanfreq", "sd", "חציון", "Q25", "Q75", "IQR", "הטיה", "קורט", "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") שמות שם (x) <- c (1: nrow (x)) return (x)}

processFolder <- function (folderName) { # התחל עם data.frame ריק. data <- data.frame () # קבל רשימת קבצים בתיקיה. list <- list.files (תיקיית שם, '\. wav') # הוסף רשימת קבצים ל- data.frame לעיבוד. עבור (שם קובץ ברשימה) {שורה <- data.frame (שם קובץ, 0, 0, 20) נתונים <- rbind (נתונים, שורה)} # הגדר שמות של עמודות. שמות (נתונים) <- c ('sound.files', 'selec', 'start', 'end') # העבר לתיקייה לעיבוד. setwd (תיקיית שם) # עיבוד קבצים. אקוסטיקה <- specan3 (נתונים, מקבילים = 1) # מעבר חזרה לתיקיית האב. setwd ('..') אקוסטיקה}

gender <- function (filePath) {if (! exist ('genderBoosted')) {load ('model.bin')} # נתיבי הגדרה. currentPath <- getwd () שם קובץ <- שם בסיס (filePath) נתיב <- dirname (filePath) # הגדר ספרייה לקריאת קובץ. setwd (נתיב) # התחל עם data.frame ריק. data <- data.frame (שם קובץ, 0, 0, 20) # הגדר שמות של עמודות. שמות (נתונים) <- c ('sound.files', 'selec', 'start', 'end') # עיבוד קבצים. אקוסטיקה <- specan3 (נתונים, מקבילים = 1) # שחזור נתיב. setwd (currentPath) לחזות (genderCombo, newdata = אקוסטיקה)}

# לטעון מידע

דליפה <- processFolder ('caminho para o pasta com samples de áudio com vazamento') ללא_leakage <- processFolder ('caminho para o pasta com samples de áudio sem vazamento')

# הגדר תוויות.

דליפה $ label <- 1 without_leakage $ label <- 2 נתונים <- rbind (דליפה, ללא_דליפה) נתונים $ label <- factor (data $ label, labels = c ('דליפה', 'ללא_ דליפה'))

# הסר עמודות שאינן בשימוש.

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

# הסר שורות המכילות NA.

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

# כתוב את מערך הנתונים של csv.

write.csv (נתונים, קובץ = 'features.csv', sep = ',', row.names = F)

שלב 11: גאול עצבי

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

שימוש עצבי ראשי ב- MLP (Perceptron Multilayer), דוגמנית לאחת מהדרכים של זיהוי והכנת אמצעי השתלה או מודל השתלה ללא שיטה מבצעת זיהוי אוטומטי של סינאלים חדשים, מידע נוסף על כך שאנו יכולים להבחין.

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 שטחי 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 system de detecção um algoritmo um pouco diferente seria usado, pois ele realizaria o treino ou receberia um modelo yes trainado da nuvem ou de alguma outra fonte e com esse modelo realizaria as predições para cada leitura realizada.

# קידוד: utf-8

ייבא פנדות כ- pd

יבוא numpy כ- np מ- sklearn.model_selection ייבוא train_test_split כ- tts מ- sklearn.neural_network ייבוא MLPClassifier כ- MLP מתוך sklearn.metrics יבוא סיווג_דיווח כ- cr מ- sklearn.metrics יבוא בלבול_מטריקס כ- 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 עצבי

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) תוצאה = modelo.predict (X_test)

# תוצאות אימפרימינדו

report = cr (Y_test, result) mat = cm (y_pred = result, y_true = Y_test) הדפסה ("Matriz de confusão") הדפסה (mat, end = "\ n / n") הדפסה ("Relatório de Classificação") הדפסה (להגיש תלונה)