Vazamentos automatinė lokalizavimo sistema: 11 žingsnių

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:45

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

Procesas skirtas tėvams ir įgyvendinamas DRAGONBOARD 410c diegimo algoritmas. Os dados também são enviados para um serviço na nuvem, reagavimas į pagalbinį procesą be integruotos dirbtinės projektavimo.

Este projeto foi desenvolvido no Hackaton Qualcomm, durante a TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), dalyvavimas projektų rengimo programoje, skirtas engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousarrír Gomesas Polo ir Ronaldo P. Gomesas Polo. Dalyvaukite projekte ar pradiniame projekte Daniel de Castro Pacheco, baigę Engenharia mecânica ir Universidade Newton Paiva de Belo Horizonte. O projeto contou com or apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro ir Felipe Crispim da Silva Salvagnini.

1 žingsnis: Lista De Materiais

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

1 „Arduino Due“

1 „Dragonboard 410c“

2 tvarkyklės, skirtos nuolatiniam variklio varikliui:

4 Transistoriai BC548

4 diodai 1n4007

4 Resistres 4k7Ω ¼ W

1 Vairuotojas su servo varikliu:

1 Transistoriai BC548

1 diodai 1N4007

1 Resistres 4k7Ω ¼ W

1 USB pelė

1 „Teclado USB“

1 Monitorius

1 HDMI kabelis

1 Robô De Esteiras - „Plataforma Zumo“

1 mini kreminės ir angliškos spalvos dispozicija

1 servo variklis 9g

2 žingsnis: „Adaptação Mecânica“

Jei norite, kad būtų įrengtas vandens telkinių daviklis, pjezoelétrico, faz se requiredá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 trator de um vykdymo tempai, fiksavimas ar disponavimas plačiaformaciniu būdu, panaudojimas fita dupla face, conforme video.

3 žingsnis: „Acionamento Dos Motores“

ZUMO e dispositivo de captura, vykdomojo ir judančiojo motoroleriai, reikalingi montuotojai ir montuojantys vairuotojus, norintiems nuolatos vairuoti variklio servo variklį, patvirtinti figuras acima, siųsti pagrindinę figūrą ar vairuotojo para um motor de corrente continua ea segunda o driver para um servo motor.

4 žingsnis: Obtenção Do Áudio

Para obtenção do espectro de áudio das vibrações do solo, fori utilizado um dispositivo desenvolvido como parte do TCC de Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro ir Felipe C. da Silva Salvagnini, daugiau informacijos paštu [email protected].

Esamas įrenginio panaudojimas-tai jutiklio pjezoelektrinis ir plačiosios grandinės diapazonas, leidžiantis realizuoti filtrą ir sustiprinti sinalį.

Kaip dažni įdomūs projektai, kurių vertė yra 100 Hz ir 800 Hz. Para isso o dispositivo de sensoriamento for configurado com uma frequência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, on frequência de aquisição deve estar pelo menos duas vezes acima das frequadncias.

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

5 veiksmas: „Configuração Do Arduino DUE“(kalbų kalba C)

Devido a grande quantidade de dados, cerca de 3000 täps por segundo, do tipo inteiro de 32 bit, gerados pelo dispositivo de sensoriamento e vajadzimai, reikalingi procesų procesams ir DRAGONBOARD 410c procesoriui, naudojant ar Arduino DUE para fazer uso de uma entrada analógica com maior procesorius, taip pat būtinas „Shield“sąsajos priedas „Grove Seeed Sensor Mezzanine“, montuojamas „DRAGONBOARD 410c“, mikrokomunikacijų valdiklis ATmega 328, nenaudojamas procesoriaus procesorius.

Ar „Arduino DUE“konfigūracija, skirta imtuvams, skirtiems enviados da plataforma, „QUALCOMM DRAGONBOARD 410c“per serijos komunikacijas.

Kaip konfigūracija be „Arduino“:

Realizar a aquisição dos dados;

„DRAGONBOARD 410c“siųstuvas;

Sukurkite programą:

#include #define 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; unsigned long int DAC [Numb_Sample], ind = Numb_Sample; void TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); jei (Scont

1); // 50% darbo ciklas

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

negaliojanti sąranka ()

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

tuštumos kilpa ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int indeksas = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); jungiklis (rc) {atvejis 1: indeksas = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indeksas << = 8; indeksas += rc; while (! Serial.available ()); } Serijinis atspaudas (0); Serijinis atspaudas (2); SendNumber (DAC [indeksas]); Serijinis atspaudas (0xFF); pertrauka; 3 atvejis: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; vėlavimas (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; vėlavimas (500); Serijinis atspaudas (0); Serijinis spaudinys (4); Serijinis atspaudas (0xFF); } pertrauka; }} else if (rc == '2') {Serial.print ("Test Servo Motor / n"); while (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("1 režimas / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("2 režimas / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; vėlavimas (100); SNow = PosServoMin; vėlavimas (100); }

6 žingsnis: „Interfaceamento Das Tecnologias“

„Arduíno DUE ea DRAGONBOARD 410c“, skirto komunikacijai, inicijuoti sąsają su paveikslėlio išvaizda, o galimi vykdytojai, pradėti naudotis opciono sąsaja, USB CDC įvestis arba „Arduino DUE ea DRA“, KERNEL da DRAGONBOARD 410c reikia sudaryti reikiamą kompoziciją, nes tai gali sukelti tam tikrą tempą.

7 veiksmas: konfigūruokite „DRAGONBOARD 410c“(„Python“)

Arduino DUE konfigūracijos konfigūracija DUE os comandos para realizar a aquisição de dados and perdavimo os dados obtidos. Segue código abaixo.

Stebėjimas: 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 inkpatíveis. Tai yra galimybė prisijungti prie USB sąsajos, kuri reikalinga KERNEL ir DRAGONBOARD 410c kompiliavimui, kad būtų užtikrinta tinkama informacija apie komunikaciją.

importuoti laikąimportuoti serijinio importo pandas kaip pd importuoti numpy kaip np

# Konfigūravimo serija

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

ser.isOpen ()

print ('Įveskite savo komandas žemiau. / r / nĮterpkite "exit", kad išeitumėte iš programos.')

įvestis = 1

o 1: įvestis = įvestis (">>"), jei įvestis == 'išeiti': 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“siųstuvas os dados coletados

sąrašas =

i diapazone (3000):

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

8 veiksmas: „INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO“

Jei norite, kad WAV būtų sukurtas, ar ne, reikia formuoti WAV, nesvarbu, kas yra automatinis TCC ir bendrų kūrinių projektavimas, ar ne, ar ne, ar ne, ar ne?. Norėdami realizuoti esta pokalbį su eskrito algoritmu PYTHON 3, galite rasti WAV ir išgelbėti CSV failą. Atsisiųskite algoritmą, skirtą abaixo ir emexo atsisiųsti.

Esesis algoritmas nereikalauja, kad sistema veiktų funkciniu būdu, o tai yra Arduino DUE.

# kodavimas: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

importo banga importas numpy kaip np importas pandas kaip pd importas matplotlib.pyplot kaip plt

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

def audio_to_csv (failo_pavadinimas): 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 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 (signalas), pd. DataFrame (laikas)], ašis = 1) df.to_csv (failo_pavadinimas + '.csv', indeksas = Netiesa) return df

# CARREGANDO DUOMENŲ RĖMAS „COM OS DADOS DO AUDIO“

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

# GRÁFICO DO ESPECTRO DE AUDIO

paveikslas, (ax1, ax2) = plt.subplots (nrows = 2, ncols = 1, figsize = (20, 10)) ax1.plot (df_vazamento ['laikas'], df_vazamento ['amp']) ax1.set_title ('Solo com Vazamento', fontdict = {'fontsize': 20, 'fontweight': 'bold'}) ax1.set_xlabel ('Tempa [s]', fontdict = {'fontsize': 16}) ax1.set_ylim ([-4e8, 4e8]) ax2.plot (df_sem_vazamento ['laikas'], 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]) figūra.tiht_layout (h_pad = 5) plt.show ()

9 žingsnis: „Anualise Visual Do Sinal“

Com PYTHON 3 realizacija ir Furjė transformacija, esą dirbtinis matematinis realizavimas ir transformacija, kuriai būdingas sinonimas, dominuojantis tempas arba dažnas frequência, vienas iš torna galimų analizių, kaip įvairios dažnio, amplitudės ir kompozicijos. Furjė transformacijos, skirtos Furjė profesinei komunistinei sistemai, specialiai apibrėžtai, specialiai atpažįstamai ir egzistuojančiai, vazamento na tubulação. Estes gráficos servirão para validção das análises realizadas pelo algoritmo de detecção automática.

Ribojamas arba dažnas dažnių diapazonas nuo 100 Hz iki 800 Hz, fica claro ir egzistuojanti vazamentos quando se stebėjimo distúrbios nesse range de frequências.

# kodavimas: utf-8# Metodinis utilizados for processamento da transformada de Fourier

importuoti pandas kaip pd importuoti numpy kaip np importo bangą iš matplotlib importo pyplot kaip plt# Função que realizacija ir Furjė transformacija ir grafika Furjė analoge (df_list): Fs = 44100; # Taksonas de amostragem em Hz Ts = 1,0/Fs; # Intervalo de amostragem y = pd.concat (df_list) t = y ['time'] # Vetor de temppos y = y ['amp'] # Vetor de amplitudes n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [diapazonas (n // 2)] Y = np.fft.fft (y)/n Y = Y [diapazonas (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.sublotai (2, 1, figsize = (20, 10)) ax [0]. plot (t, y) ax [0].set_xlabel („Laikas“) kirvis [0]..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 realize a carga dos dados do CSV and chama a função de Fourier def read_csv (file_name, init, final): df = pd.read_csv (failo_pavadinimas + '.csv') df.columns = ['amp', ' laikas '] delta = final-init, jei init*44100> len (df) arba final*44100> len (df): init = (len (df)/44100) -delta, jei init = 100) & (df [' freq '] <= 800)] mx = surūšiuotas (df [' amp ']) print ("Média das amplitudės:", np.aplink (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") print ("100 maiores amplitudės", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplitudės:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplitudės:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maior amplitudė:", 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) # Pavyzdys gr.

10 veiksmas: „Algoritmo Em R Para Extração Das Features Dos Dados“

Utilizuokite savo algoritmą ir supraskite procesų ir papildomų funkcijų ypatybes (charakteristikas).

Esminis pirminis algoritmas realizuoja papildomą identifikavimą, yra būtinas ir reikalingas, kad būtų galima atpažinti, ar ne, ar ne, ar ne, ar ne, ar ne, ar ne, ar ne, ar ne, ar ne?

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 identifada, gerando somente as características sem uma identifação.

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

Esminis algoritmas, skirtas dalijimui, kuris nėra skirtas „GitHub“ir „pode“, skirtų atrasti atsisiuntimo nuorodą, o mesmo foi modificado para atender kaip especificações do projeto.

O programinė įranga, naudojama rodyklėms arba nemokamam algoritmui, atsisiųskite „R e do R Studio“interpretaciją.

Papildomos charakteristikos:

• meanfreq: vidutinis dažnis (kHz)
• sd: standartinis dažnio nuokrypis
• mediana: vidutinis dažnis (kHz)
• Q25: pirmasis kvantilis (kHz)
• Q75: trečiasis kvantilis (kHz)
• IQR: interkvantilinis diapazonas (kHz)
• iškraipymas: kreivumas (žr. pastabą specifinio aprašymo metu)
• kurt: kurtosis (žr. pastabą specifiniame aprašyme)
• sp.ent: spektrinė entropija
• sfm: spektrinis lygumas
• režimas: režimo dažnis
• centroid: dažnio centroidas (žr. specifikaciją)
• peakf: didžiausias dažnis (dažnumas, turintis didžiausią energiją)
• meanfun: pagrindinio dažnio vidurkis, išmatuotas per garsinį signalą
• minfun: minimalus pagrindinis dažnis, išmatuotas per garso signalą
• maxfun: didžiausias pagrindinis dažnis, išmatuotas per garsinį signalą
• meandom: dominuojančio dažnio vidurkis, išmatuotas per garso signalą
• mindom: minimalus dominuojantis dažnis, išmatuotas per garso signalą
• maksimumas: didžiausias dominuojančio dažnio matas per garso signalą
• dfrange: dominuojančio dažnio diapazonas, išmatuotas per garsinį signalą
• modindx: moduliacijos indeksas. Skaičiuojama kaip sukauptas absoliutus skirtumas tarp gretimų pagrindinių dažnių matavimų, padalytas iš dažnių diapazono
• etiketė: nuotėkis arba be nuotėkio

Algoritmas:

paketai <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'pelės', 'e1071', 'rpart', 'xgboost', 'e1071'), jei (ilgis (setdiff (paketai, rownames (install.packages ())))> 0) {install.packages (setdiff (paketai, rownames (install.packages ())))})

biblioteka (tuneR)

biblioteka (seewave) biblioteka (caTools) biblioteka (rpart) biblioteka (rpart.plot) biblioteka (randomForest) biblioteka (warbleR) biblioteka (pelės) biblioteka (xgboost) biblioteka (e1071)

specan3 <- funkcija (X, bp = c (0, 22), wl = 2048, slenkstis = 5, lygiagretus = 1) { # Norėdami naudoti lygiagretų apdorojimą: biblioteka (devtools), install_github ('nathanvan/parallelsugar'), jei (class (X) == "data.frame") {if (visi (c ("sound.files", "selec", "start", "end") % % % pavadinimuose (X))) {start <- as.numeric (unlist (X $ start)) end <- as.numeric (unlist (X $ end)) sound.files <- as.character (unlist (X $ sound.files)) select <- as.character (unlist (X $ selec))} else stop (paste (paste (įklijuoti (c ("sound.files", "selec", "start", "end")) [! (c ("sound.files", "selec", "start", "end") % % colnames (X))], collapse = ","), "stulpelis (-ai) nerastas duomenų rėmelyje"))} else stop ("X nėra duomenų rėmas")) #jei pradžioje arba pabaigoje yra NA, jei (bet koks (is.na (c (pabaiga, pradžia))))) sustoja („NA rasti pradžioje ir (arba) pabaigoje“) #jei pabaiga ar pradžia nėra skaitinė stotelė if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' ir 'selec' turi būti skaitiniai") #jei bet kuri pradžia yra aukštesnė už pabaigą, jei (any (end - start <0)) stop (paste ("Pradžia yra aukštesnė nei en d in ", ilgis (kuris (pabaiga - pradžia20)) stop (įklijuoti (ilgis (kuris (pabaiga - pradžia> 20))),„ pasirinkimas (-ai) ilgesnis nei 20 sek. ") parinktys (show.error.messages = TRUE) #jei bp nėra vektorius arba ilgis! = 2 sustojimas, jei (! is.vector (bp)) stop ("" bp 'turi būti 2 ilgio skaitinis vektorius ") else {if (! length (bp) == 2) stop ("" bp 'turi būti 2 ilgio skaitinis vektorius ")} #return įspėjimas, jei ne visi garso failai buvo rasti fs <- list.files (path = getwd (), pattern =".wav $ ", ignoruoti. atvejis = TIESA) if (ilgis (unikalus (garso.files [(garsas.lt % % % fs)])))! = ilgis (unikalus (garsas.lt))) katė (įklijuoti (ilgis (unikalus (garsas). failai))-ilgis (unikalus (sound.files [(garso.files % % % fs)])), ".wav failas nerastas")) #garso failų skaičius darbo kataloge ir jei 0 sustojimas d <- kuris (garso.files % % fs), jei (ilgis (d) == 0) {stop (".wav failų nėra darbo kataloge")} else {start <- start [d] end <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Jei paralelė nėra skaitinė, jei (! is.numeric (parallel)) stop (" būti 1 "ilgio skaitinis vektorius), jei (bet koks (! (lygiagretus %% 1 == 0), lygiagretus 1) {parinktys (įspėti = -1), jei (visi (Sys.info () [1] ==" Windows ", reikalaujaNamespace (" parallelsugar ", tyliai = TRUE) == TRUE)) lapp <- funkcija (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = lygiagreti) else if (Sys.info () [1] == "Windows") {cat ("" Windows "vartotojai turi įdiegti" parallelsugar "paketą lygiagrečiam skaičiavimui (jūs to nedarote dabar!)") Lapp <- pbapply:: pblapply} else lapp <- funkcija (X, FUN) lygiagretus:: mclapply (X, FUN, mc.cores = lygiagretus)} else lapp <- pbapply:: pblapply parinktys (įspėti = 0) if (lygiagrečiai == 1) katė ("Akustinių parametrų matavimas:") x <- as.data.frame (lapp (1: ilgis (pradžia), funkcija (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), nuo = pradžia , iki = pabaiga , vienetai = "sekundės") b lubos ([email protected]/2000) - 1) b [2] < - lubos ([email protected]/2000) - 1 #dažnių spektro analizė songpec <- seewave:: spec (r, f = [email protected], plot = FALSE) analizė <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #išsaugoti parametrus meanfreq <- analizė $ vidurkis/1000 sd <- analizė $ sd/1000 mediana <- analizė $ mediana/1000 Q25 < - analizė $ QQ75 <- analizė $ QIQR <- analizė $ IQR/1000 pasvirimas <- analizė $ skewness kurt <- analizė $ kurtosis sp.ent <- analizė $ sh sfm <- analizė $ sfm režimas <- analizė $ mode/1000 centroid <- analizė $ cent/1000 #Dažnis su amplitudės smailėmis peakf <- 0 #seewave:: fpeaks (songspec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Pagrindiniai dažnio parametrai ff <- seewave:: fund (r, f = [email protected], ovlp = 50, slenkstis = slenkstis, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] meanfun <-reiškia (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Dominuojantys dažnumo parametrai y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, grafikas = F, slenkstis = slenkstis, pralaidumas = b * 1000, fftw = TRUE) [, 2] meandom <- vidurkis (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) trukmė <- (pabaiga - pradžia ) #moduliacijos indekso skaičiavimo pokyčiai <- vektorius (), skirtas (j, kuriame (! yra). na (y))) {keisti <- abs (y [j]- y [j + 1]) pakeitimai <- pridėti (keisti, keisti)} if (mindom == maxdom) modindx <-0 else modindx <- mean (pokyčiai, na.rm = T)/dfrange #save results return (c (trukmė, vidutinis dažnis, sd, mediana, Q25, Q75, IQR, iškraipymas, kurt, sp.ent, sfm, režimas, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #keisti rezultatų pavadinimus rownames (x) <- c ("duration", "meanfreq", "sd", "mediana", "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))) vardai (x) [1: 2] <- c ("sound.files", "selec") pavardės (x) <- c (1: nrow (x)) return (x)}

processFolder <- funkcija (aplanko pavadinimas) { # Pradėkite nuo tuščių duomenų. kadras. data <- data.frame () # Gauti aplanke esančių failų sąrašą. list <- list.files (folderName, '\. wav') # Pridėti failų sąrašą prie data.frame apdoroti. for (failo pavadinimas sąraše) {row <- data.frame (fileName, 0, 0, 20) data <- rbind (duomenys, eilutė)} # Nustatykite stulpelių pavadinimus. vardai (duomenys) <- c ('sound.files', 'selec', 'start', 'end') # Perkelti į aplanką apdorojimui. setwd (folderName) # Apdorokite failus. akustika <- specan3 (duomenys, lygiagretus = 1) # Perkelti atgal į pirminį aplanką. setwd ('..') akustika}

gender <- funkcija (filePath) {jei (! egzistuoja ('genderBoosted')) {load ('model.bin')} # Sąrankos keliai. currentPath <- getwd () fileName <- bazinis pavadinimas (filePath) kelias <- dirname (filePath) # Nustatykite katalogą skaityti failą. setwd (kelias) # Pradėkite nuo tuščių duomenų.rėmas. duomenys <- data.frame (fileName, 0, 0, 20) # Nustatykite stulpelių pavadinimus. vardai (duomenys) <- c ('sound.files', 'selec', 'start', 'end') # Apdorokite failus. akustika <- specan3 (duomenys, lygiagretus = 1) # Atkurti kelią. setwd (currentPath) prognozuoti (genderCombo, newdata = akustika)}

# Įkelti duomenis

nutekėjimas <- processFolder ('caminho para o pasta com sample de áudio com vazamento') without_leakage <- processFolder ('caminho para o pasta com sample de áudio sem vazamento')

# Nustatykite etiketes.

nutekėjimas $ etiketė <- 1 be_lekalės $ etiketė <- 2 duomenys <- rbind (nutekėjimas, be_lekalės) duomenys $ label <- koeficientas (data $ label, labels = c ('nuotėkis', 'be_lekalės'))

# Pašalinkite nenaudojamus stulpelius.

duomenys $ trukmė <- NULL duomenys $ sound.files <- NULL duomenys $ selec <- NULL duomenys $ peakf <- NULL

# Pašalinkite eilutes, kuriose yra NA.

duomenys <- duomenys [baigti. atvejai (duomenys),]

# Parašykite csv duomenų rinkinį.

write.csv (duomenys, failas = 'features.csv', sep = ',', row.names = F)

11 žingsnis: atkurti neuroną

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

A rede neuroninis panaudojimas ir tipo MLP (daugiasluoksnis perceptronas), modelio ir treinado com dados išankstinis identifikavimas ir apos esse treinamento arba modelio implantavimas be sistemos pasekmių realizavimo ir identifikavimo automatikos, kad būtų atliktas sinusinis gavimas, informuoti apie naquele ponto existe um vazamento ou não.

Reikalingos realizacijos 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 more paviršinis pode-se chegar a algumas varáveis com bons desempenhos.

Sėklidžių realizavimas arba modelio obteve um desempenho muito bom, alcançando na maioria dos sėklidės yra 100%taksonų koncertas, como pode ser stebėjimas ir vaizdo anexa.

Este algoritmas ir panaudojimo para treinar arba modelio da rede ir 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á treinado da nuvem ou de alguma outra fonte e com esse modelo realizaria as predições para cada leitura realizada.

# kodavimas: utf-8

importuoti pandas kaip pd

importuoti numpy kaip np iš sklearn.model_selection importuoti train_test_split kaip tts iš sklearn.neural_network importuoti MLPClassifier kaip MLP iš sklearn.metrics importuoti klasifikaciją_ ataskaitą kaip cr iš sklearn.metrics importuoti confusion_matrix kaip cm

# Leitura dos dados do CSV

df = pd.read_csv ('features.csv') ',' sd ',' Q25 ',' sfm ',' centroid ',' meandom ',' mindom '] # Separação das saidas df_Y = df [df.columns [-1] # Discretização das saidas df_Y = pd.get_dummies (df_Y) df_Y = df_Y ['nutekėjimas']

# Separando dados para treino ir teste

X_train, X_test, Y_train, Y_test = tts (df_X, df_Y, test_size = 0,1)

# Criando modelo de rede neuroninis

modelio = MLP (alfa = 0,0001, mokymosi_skaičiavimo_initas = 0,0001, paslėptų sluoksnių dydžiai = (50, 50, 50, 50), max_iteris = 10000, aktyvinimas = 'tanh', sprendėjas = 'lbfgs')

# Treinando modelis

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

# Imprimindo resultados

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