Lokalizace lokalizovaného systému: 11 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:21

Este projeto Cons em em rob rob, que através da leitura realizada por um dispositivo, equipmentado 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 neurural, possivateis vazamentos de água em uma tubulação.

Odehrává všechna vaše data a algoritmy nainstalované na DRAGONBOARD 410c. Všechny možnosti jsou k dispozici pro všechny služby, které jsou zodpovědné za integraci všech umělých procesů.

Este projeto foen desenvolvido no Hackaton Qualcomm, durante a TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), participaram do projeto os graduandos de engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodrigues, Rogér. Gomes Polo a Ronaldo P. Gomes Polo. Também se podílí na projednávání aluno Daniel de Castro Pacheco absolvent 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 e Felipe Crispim da Silva Salvagnini.

Krok 1: Seznam materiálů

Dosáhnete toho, že projednáte, nebo vyberete z následujících materiálů:

1 splatnost Arduina

1 Dragonboard 410c

2 Ovladače pro hlavní motor, který nepřetržitě podporuje následující:

4 tranzistory BC548

4 diody 1n4007

4 odpory 4k7Ω ¼ W

1 Dodatečný ovladač servomotoru pro řidiče:

1 tranzistory BC548

1 diody 1N4007

1 Rezistory 4k7Ω ¼ W

1 USB myš

1 Teclado USB

1 Monitor

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini dispositivo de cremalheira e engrenagem

1 servomotor 9 g

Krok 2: Adaptação Mecânica

Para a aquisição dos dados pelo senzor piezoelétrico, faz se needário, o desenvolvimento de um dispositivo com pinhão e cremalheira, consistente desenhos anexados, neste caso as peças foram fabricadas por uma impressora 3D, devido ao fato de se tratar de um protót tempo de execução, fixou-se o dispositivo na plataforma zumo, utilizando fita dupla face, consistente video.

Krok 3: Acionamento Dos Motores

Para executar a movimentação dos motores do robô ZUMO e do dispositivo de captura, fez-se needária a montagem de dois drivers para os motores de corrente continua e um driver para o servo motor, consistente as figuras acima, sendo a primeira figura o driver para um motor de corrente continua ea segunda o driver para um servo motor.

Krok 4: Obtenção Do Áudio

Více než jedna vibrace do sóla, což znamená, že lze využít více než jednu TCC de Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro e Felipe C. da Silva Salvagnini, maiores detalhes sobre o TCC e sobre o dispos e -mail [email protected].

K dispozici jsou různé možnosti piezoelektrického senzoru, piezoelektrické snímače a filtrační zesilovače.

Jedná se o frekvenci, která se týká projektu o frekvenci 100 Hz až 800 Hz. Paros isso o dispositivo de sensoriamento fori configurado com uma frekvence frekvencí de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, one a frequencyência de aquisição deve estar pelo menos duas verzes acima das Frequênes.

Aquisição é habilitada and desabilitada através da interrupção do Arduino DUE.

Krok 5: Configuração Do Arduino DUE (linguagem C)

Nabízí velké a velké množství bitů s celkovým počtem 3000 bitů, více než 32 bitů, základní paměťové senzory a základní požadavky na procesorové algoritmy DRAGONBOARD 410c, které využívají Arduino DUE para fazer uso de uma entrada analógica com základní proces, nutný pro váš o Shield de interfaceamento Grove Seeed Sensor Mezzanine instalado na DRAGONBOARD 410c, que possui um microcontrolador ATmega 328, não possui spoder de processamento para essa operacao.

O Arduino DUE konfiguruje para přijímače nebo kombinuje základní desky QUALCOMM DRAGONBOARD 410c prostřednictvím sériového rozhraní.

Jako konfigurace bez Arduino foram:

Realizar a aquisição dos dados;

Vysílejte více než DRAGONBOARD 410c;

Prohlédněte si program:

#include #define Numb_Sample 3000 #define DAC_Input A0

#define SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Perioda 60 unsigned int Scont = 0, SNow = PosServoMin; unsigned long int DAC [Numb_Sample], ind = Numb_Sample; neplatné TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analogRead (DAC_Input); pokud (Scont

1); // 50% pracovní cyklus

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

neplatné nastavení ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Spuštění časovače // TC_Stop (TC1, 0); pinMode (SERVO, VÝSTUP); }

prázdná smyčka ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int index = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); přepínač (rc) {případ 1: index = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {index << = 8; index += rc; while (! Serial.available ()); } Serial.print (0); Serial.print (2); SendNumber (DAC [index]); Serial.print (0xFF); přestávka; případ 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; zpoždění (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; zpoždění (500); Serial.print (0); Serial.print (4); Serial.print (0xFF); } přestávka; }} else if (rc == '2') {Serial.print ("Test servomotoru / n"); while (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Režim 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Mode 2 / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; zpoždění (100); SNow = PosServoMin; zpoždění (100); }

Krok 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 possível executar, então optou-se pelo uso de uma interface USB CDC entre o Arduino DUE ea DRAGONBOARD 4 nezbytně nutné pro rekompilaci KERNEL da DRAGONBOARD 410c, que não se fez por causa do curto tempo disponibil.

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

Konfigurace je možná pro Arduino DUE a to jak pro realizaci, tak pro přenos a přenos dat. Segue código abaixo.

Pozorování: Abordagem utilizada no código, não funcionou devido aos níveis de tensão utilizados pelo Arduíno DUE e o Mezzanine serem nekompatibilní. Naše rozhraní je možné vybírat z více USB, což je nutné pro KERNEL na DRAGONBOARD 410c pro více portů a více pro Corretamente pro komunitu.

import timeimport sériový import pandy jako pd import numpy jako np

# Konfiguração da conexão seriál

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

ser.isOpen ()

print ('Níže zadejte své příkazy. / r / nVložením „exit“aplikaci opustíte.)

vstup = 1

while 1: input = input (">>") if input == 'exit': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comando para o Arduino DUE realizovat Coleta dos dados ser.write (1) # Envia o comando para o Arduino DUE transmitir os dados coletados

lista =

pro i v rozsahu (3000):

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

Krok 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar prima anialise dos dados obtidos através do sensor, so fez needária and conversão dos arquivos no formatato WAV, fornecidos pelos alunos autores to TCC e colaboradores do projeto, para valores numéricos, que são use a useados nos algoritms of anadise embar. Para realizace nebo konverze algoritmu PYTHON 3 que lê o arquivo WAV e salva os dados do espectro em um arquivo CSV. Algoritmy využívají abaixo e em anexo para download.

Algoritmy, které je třeba provést, vyžadují základní funkce, já se starám o Arduino DUE já enviará eses dados em um array de valores numéricos.

# kódování: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

import vlna 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 (název_souboru): 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_s) 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 (signál), pd. DataFrame (čas)], osa = 1) df.to_csv (název_souboru + '.csv', index = False) návrat df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

název_souboru = 'Solo_com_Vazamento' df_vazamento = audio_to_csv (název_souboru) df_vazamento.columns = ['amp', 'time'] file_name = 'Solo_sem_Vazamento' df_sem_vazamento = audio_to_csv (název_souboru) [df_sem_va]

# GRÁFICO DO ESPECTRO DE AUDIO

obrázek, (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 = {'velikost písma': 20, 'fontweight': 'bold'}) ax1.set_xlabel ('Tempo [s]', fontdict = {'velikost písma': 16}) ax1.set_ylim ([-4e8, 4e8]) ax2.plot (df_sem_vazamento ['time'], df_sem_vazamento ['amp']) ax2.set_title ('Solo sem Vazamento', fontdict = {'velikost písma': 20, 'fontweight': 'tučné' }) ax2.set_xlabel ('Tempo [s]', fontdict = {'velikost písma': 16}) ax2.set_ylim ([-4e8, 4e8]) figure.tight_layout (h_pad = 5) plt.show ()

Krok 9: Analise Visual Do Sinal

Com o PYTHON 3 a realizade a transformade de Fourier, este artificio matemático realiza a transformação do sinal do domínio do tempo para o domínio da frequencyência, onde se torna possível analisar as varias Frequências, e suas amplitude, que compõem aquele sinal. Všechny vizuální efekty se dají přeměnit na Fourierovy a profesionální profese, které se týkají konkrétních identifikací a existujících vazeb na tubuly. Naše hlavní funkce pro optimalizaci automatizované detekce algoritmů.

Frekvence může dosahovat 100 Hz až 800 Hz, přičemž většina vašich vazeb má své vlastní rozsahy frekvencí.

# coding: utf-8# Použití modulů pro proces transformace nebo Fourierova transformace

import pand jako pd import numpy as np import wave from matplotlib import pyplot as 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 amplitudy n = len (y) # Comprimento do sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [rozsah (n // 2)] Y = np.fft.fft (y)/n Y = Y [rozsah (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) fig, ax = plt.subplots (2, 1, figsize = (20, 10)) ax [0].plot (t, y) ax [0].set_xlabel ('Time') ax [0].set_ylabel ('Amplitude') ax [1].plot (frq, abs (Y), 'r') ax [1].set_xlim ([100, 800]) ax [1].set_ylim ([0, max_lim]) ax [1].set_xlabel ('Freq (Hz)') ax [1].set_ylabel ('| Y (freq) |') plt.show () návrat 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) or final*44100> len (df): init = (len (df)/44100) -delta if init = 100) & (df [' freq '] <= 800)] mx = seřazeno (df [' amp ']) print ("Média das amplitude:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitude.") print ("100 maiores amplencies", np.mean (mx [-100:]) // df ['amp']. průměr ()*100, "%", sep = "") tisk ("50 maioresových amplitud:", np.mean (mx [-50:]) // df ['amp']. průměr ()*100, "%", sep = "") tisk ("10 maioresových amplitud:", np.mean (mx [-10:]) // df ['amp']. průměr ()*100, "%", sep = "") tisk ("Maior amplituda:", np.mean (mx [-1:]) // df ['amp']. průměr ()*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

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

Využití a algoritmus R Para Realizace nebo extra funkce a další funkce (vlastnosti) mohou být získány.

Algoritmy hlavní implementace mohou zahrnovat další identifikaci, další a nejdůležitější způsob, jak rozpoznat, detekovat nebo zintenzivnit detekci všech vašich výsledků, což může mít za následek další proces, který může mít za následek další neurální využití.

Různé způsoby, jakými se liší od různých operačních systémů, jsou různé algoritmy, které umožňují různé způsoby provádění, identifikace a rozpoznávání, jako jsou například hlavní charakteristiky a identifikace.

Estas features au 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.

Většina algoritmů, které mají k dispozici, nemají k dispozici žádný GitHub, které by mohly mít přístup k propojení, nebo mohou upravovat různé parašutisty jako konkrétní specifikace.

O software usado para rodar o algoritmo é gratuito, download do interpretador R e do R Studio.

Zvláštní vlastnosti:

• průměrná frekvence: střední frekvence (v kHz)
• sd: standardní odchylka frekvence
• medián: střední frekvence (v kHz)
• Q25: první kvantil (v kHz)
• Q75: třetí kvantil (v kHz)
• IQR: mezikvantilní rozsah (v kHz)
• zkosení: šikmost (viz poznámka v popisu speciálního návrhu)
• kurt: kurtóza (viz poznámka v popisu speciálního návrhu)
• sp.ent: spektrální entropie
• sfm: spektrální plochost
• režim: frekvence kmitočtu
• těžiště: těžiště frekvence (viz specifikace)
• peakf: špičková frekvence (frekvence s nejvyšší energií)
• Meanfun: průměr základní frekvence měřený napříč akustickým signálem
• minfun: minimální základní frekvence měřená přes akustický signál
• maxfun: maximální základní frekvence měřená přes akustický signál
• meandom: průměr dominantní frekvence měřený napříč akustickým signálem
• mindom: minimum dominantní frekvence měřené napříč akustickým signálem
• maxdom: maximum dominantní frekvence měřené napříč akustickým signálem
• dfrange: rozsah dominantní frekvence měřený napříč akustickým signálem
• modindx: modulační index. Vypočítáno jako kumulovaný absolutní rozdíl mezi sousedními měřeními základních frekvencí dělený frekvenčním rozsahem
• štítek: únik nebo bez_únik

Algoritmo usado:

balíčky <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'mouse', 'e1071', 'rpart', 'xgboost', 'e1071') if (délka (setdiff (balíčky, názvy řádků (nainstalované.packages ())))> 0) {install.packages (setdiff (balíčky, názvy řádků (nainstalované.packages ())))}

knihovna (tuneR)

knihovna (seewave) knihovna (caTools) knihovna (rpart) knihovna (rpart.plot) knihovna (randomForest) knihovna (warbleR) knihovna (myši) knihovna (xgboost) knihovna (e1071)

specan3 <- funkce (X, bp = c (0, 22), wl = 2048, práh = 5, paralelně = 1) { # Použití paralelního zpracování: knihovna (devtools), install_github ('nathanvan/parallelsugar') if (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))} else stop (paste (paste (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "start", "end") % in % colnames (X))], collapse = ","), "sloupec (y) nebyl nalezen v datovém rámci"))} else stop ("X není datový rámec") #if pokud jsou NA na začátku nebo na konci zastávky, pokud (libovolný (is.na (c (konec, začátek)))) stop („NA nalezené na začátku a/nebo na konci“) #pokud konec nebo začátek nejsou číselné zastavení if (all (class (end)! = "numeric" & class (start)! = "numeric")) stop ("'end' and 'selec' must be numeric") #if any start higher than end stop if (any (end - start <0)) stop (vložte („Začátek je vyšší než en d in ", length (which (end - start20)) stop (paste (length (which (end - start> 20))," selection (s) longer than 20 sec ")) options (show.error.messages = TRUE) #if bp není vektor nebo délka! = 2 zastavení, pokud (! is.vector (bp)) stop ("'bp' musí být číselný vektor délky 2") else {if (! length (bp) == 2) stop ("'bp' musí být číselný vektor o délce 2")} #upozornění na návrat, pokud nebyly nalezeny všechny zvukové soubory fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (length (unique (sound.files [(sound.files % in % fs)])))! = length (unique (sound.files))) cat (paste (length (unique (sound. soubory))-délka (jedinečná (sound.files [(sound.files % in % fs)])), ".wav file (s) not found")) #count number of sound files in working directory and if 0 stop d <- který (sound.files % in % fs) if (length (d) == 0) {stop ("The.wav files are not in the working directory")} else {start <- start [d] end <- konec [d] výběr <- výběr [d] sound.files <- sound.files [d]} # Pokud rovnoběžka není číselná, pokud (! is.numeric (paralelní)) stop ("'paralelní' musí být numerický vektor o délce 1 ") if (libovolný (! (paralelní %% 1 == 0), paralelní 1) {možnosti (varování = -1) if (vše (Sys.info () [1] ==" Windows ", requireNamespace (" parallelsugar ", tiše = TRUE) == TRUE)) lapp <- funkce (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = paralelní) else if (Sys.info () [1] == "Windows") {cat ("Uživatelé Windows si musí nainstalovat balíček 'parallelsugar' pro paralelní výpočet (teď to neděláte!)") Lapp <- pbapply:: pblapply} else lapp <- funkce (X, FUN) paralelní:: mclapply (X, FUN, mc.cores = paralelní)} else lapp <- pbapply:: pblapply možnosti (varovat = 0) if (paralelně == 1) cat ("Měření akustických parametrů:") x <- as.data.frame (lapp (1: délka (start), funkce (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files )), od = start , to = end , units = "seconds") b strop ([email protected]/2000) - 1) b [2] < - strop ([email protected]/2000) - 1 #frekvenční spektrální analýza songpec <- seewave:: spec (r, f = [email protected], plot = FALSE) analýza <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #parametry uložení průměrná frekvence <- analýza $ průměr/1000 sd <- analýza $ sd/1000 medián <- analýza $ medián/1000 Q25 < - analýza $ QQ75 <- analýza $ QIQR <- analýza $ IQR/1000 zkosení <- analýza $ šikmost kurt <- analýza $ kurtosis sp.ent <- analýza $ sh sfm <- analýza $ sfm režim <- analýza $ režim/1000 těžiště <- analýza $ cent/1 000 #Frekvence s vrcholy amplitudy vrcholf <- 0 #seewave:: fpeaks (písněpec, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Základní frekvenční parametry ff <- viz vlna:: fond (r, f = [email protected], ovlp = 50, práh = práh, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] průměrná zábava <-průměr (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Dominantní parametry frekvence y <- viz vlna:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, threshold = threshold, bandpass = b * 1000, fftw = TRUE) [, 2] meandom <- průměr (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) doba trvání <- (end - start ) #modulační výpočet se změní <- vektor () pro (j, ve kterém (! is. na (y))) {změna <- abs (y [j]- y [j + 1]) změny <- připojení (změny, změna)} if (mindom == maxdom) modindx <-0 else modindx <- průměr (změny, na.rm = T)/dfrange #uložit výsledky návratu (c (doba trvání, průměrná frekvence, sd, medián, Q25, Q75, IQR, zkosení, kurt, sp.ent, sfm, režim, těžiště, peakf, průměrná zábava, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))}))) #Change result names names rownames (x) <- c ("duration", "meanfreq", "sd", "median", "Q25", „Q75“, „IQR“, „zkosení“, „kurt“, „sp.ent“, „sfm“, „režim“, „těžiště“, „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") názvy řádků (x) <- c (1: nrow (x)) return (x)}

processFolder <- funkce (název složky) { # Začněte prázdným datovým rámcem. data <- data.frame () # Získá seznam souborů ve složce. list <- list.files (název složky, '\. wav') # Přidejte seznam souborů do data.frame pro zpracování. for (název souboru v seznamu) {řádek <- data.frame (název souboru, 0, 0, 20) data <- rbind (data, řádek)} # Nastavte názvy sloupců. names (data) <- c ('sound.files', 'selec', 'start', 'end') # Přesunout do složky pro zpracování. setwd (název_složky) # Zpracujte soubory. acoustics <- specan3 (data, parallel = 1) # Přesunout zpět do nadřazené složky. setwd ('..') akustika}

pohlaví <- funkce (filePath) {if (! existuje ('genderBoosted')) {load ('model.bin')} # instalační cesty. currentPath <- getwd () fileName <- basename (filePath) cesta <- dirname (filePath) # Nastavit adresář pro čtení souboru. setwd (cesta) # Začněte prázdným datovým rámcem. data <- data.frame (název_souboru, 0, 0, 20) # Nastavte názvy sloupců. names (data) <- c ('sound.files', 'selec', 'start', 'end') # Process files. acoustics <- specan3 (data, parallel = 1) # Obnovte cestu. setwd (currentPath) predikce (genderCombo, newdata = acoustics)}

# Načíst data

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

# Nastavit štítky.

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

# Odstraňte nepoužívané sloupce.

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

# Odstraňte řádky obsahující NA.

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

# Zapište datovou sadu CSV.

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

Krok 11: Rede Neural

Naše myšlenka je neurální, což znamená, že jsme provedli novou rekonstrukci automatizovaných technologií, abychom získali co největší počet senzorů.

A rede neurural utilizada a 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 ainal recipientbido, informando se naquele ponto existe um vazamento.

Je nutné provést filtraci, která se bude skládat z jedné z následujících skupin, přičemž všechny tyto dimenze budou mít různé taxony a taxony, které se budou dále objevovat. Nainstalovali jsme všechny běžné aplikace, které se zabývají povrchovými pode-se chegar a algumas variáveis com bons desempenhos.

Para os vares realizoos or modelo obteve um desempenho muito bom, alcançando on maioria dos testes uma taxa de acerto de 100%, como pode ser observado on imagem anexa.

Algoritmus a využití parašutistických a modulárních režimů se projeví a zpomalí. Žádný systém detekce různých algoritmů, které by mohly odlišovat sérii usadit, 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.

# kódování: utf-8

importovat pandy jako pd

import numpy as np from sklearn.model_selection import train_test_split as tts from sklearn.neural_network import MLPClassifier as MLP from sklearn.metrics import distribution_report as cr from sklearn.metrics import confusion_matrix as 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 neural

model = MLP (alpha = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10 000, aktivace = 'tanh', solver = 'lbfgs')

# Treinando modelo

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

# Imprimindo resultados

report = cr (Y_test, result) mat = cm (y_pred = result, y_true = Y_test) tisk ("Matriz de confusão") tisk (mat, end = "\ n / n") tisk ("Relatório de Classificação") tisk (zpráva)