Sistema Autônomo Localizador De Vazamentos: 11 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

ეს არის პროტოტიპი, რომელიც მოიცავს ჩვენს მიერ გაცემულ რეალიზაციას, რომელიც განისაზღვრება ჩვენი მოწყობილობის სენსორული აღჭურვილობის გამოყენებით, რომელიც აღწერს არა მარტო სხივებს, არამედ ადგილსამყოფელს, რაც ჩვენ ვსაუბრობთ ჩვენი ნერვული მდგომარეობის შესახებ uma tubulação.

O processamento destes dados é realizado for algoritmos instalados na DRAGONBOARD 410c. Os dados também são enviados para um serviço na nuvem, respondável for 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), მონაწილეობა მიიღოს პროექტების შემდგომ განვითარებაში, რომლებიც წარმოიქმნება engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavio, Rodas, ლუკას დე ლუიეს სიუგიე, ლუკას დე ლუის აპიეს გომეს პოლო და რონალდო პ. გომეს პოლო. დანიელ დე კასტრო პაჩეკოს მონაწილეობა მიიღო ნიუტონ პაივა დე ბელო ჰორიზონტის უნივერსალურ უნივერსიტეტში. O projeto contou com o apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro e Felipe Crispim da Silva Salvagnini.

ნაბიჯი 1: სია მასალების შესახებ

გააცნობიეროს დანიშნულებისამებრ, რომელიც გამოიყენება გამოყენებული მასალებისათვის:

1 Arduino გამო

1 Dragonboard 410c

2 მძღოლი para motor de corrente Continua contendo cada um:

4 ტრანზისტორი BC548

4 დიოდოსი 1n4007

4 რეზისტენტული 4k7Ω ¼ W

1 მძღოლი servo motor contendo– სთვის:

1 ტრანზისტორი BC548

1 დიოდოს 1N4007

1 რეზისტენტული 4k7Ω ¼ W

1 მაუსი USB

1 Teclado USB

1 მონიტორი

1 Cabo HDMI

1 Robô De Esteiras - Plataforma Zumo

1 მინი განკარგვის კრემალი და ინჟინერია

1 სერვო ძრავა 9 გ

ნაბიჯი 2: ადაპტირება მექანიკა

Para aquisição dos dados pelo სენსორი piezoelétrico, faz se needário, o desenvolvimento de um dispitivo com pinhão e cremalheira, conforme desenhos anexados, neste caso as peças foram fabricadas por uma impressora 3D, devido ao fato tempo de execução, fixou-se o dispositivo na plataforma zumo, utilisando fita dupla face, conforme vídeo.

ნაბიჯი 3: Acionamento Dos Motores

Para ekzotar a movimentação dos motores do robô ZUMO e do dispositivo de captura, fez-se need a montagem de dois drivers para os motores de corrente Continua e um driver para o servo motor, conforme as figuras acima, sendo a Primeira figura o driver para um motor de corrente Continua და segunda ან მძღოლი და servo motor.

ნაბიჯი 4: Obtenção Do Áudio

Para obtenção do espectro de áudio das vibrações do solo, foi utilisado um dispositivo desenvolvido como parte do TCC de Engenharia Mecatrônica dos graduandos ლუკას ნუნეს მონტეირო და ფელიპე C. da Silva Salvagnini, maiores disalit soebra sobe oravas sober ელ.ფოსტა [email protected].

ეს არის გამოყენებული სენსორი, რომელიც იყენებს სისტემურ სისტემას, რომელიც ახორციელებს ფილტრაციას და გაძლიერებას.

როგორც ინტერესთა სიხშირე, რომელიც მოიცავს 100Hz და 800Hz. მგრძნობელობის განმსაზღვრელი სიხშირის კონფიგურაციის სიხშირე 3 კჰჰც -მდე, რათა განვსაზღვროთ, თუ როგორ ვსწავლობთ ამ ნიუანსის ამორტიზაციულ სიხშირეზე, რაც ხშირად ხდება წყლის სიხშირეების სიხშირეზე.

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

ნაბიჯი 5: კონფიგურაცია Do Arduino DUE (ენა C)

Devido a grande quantidade de dados, cerca de 3000 pontos for segundo, do tipo inteiro de 32 bit, gerados pelo dispositivo de sensoriamento e e needários for processamento dos dos algoritmos na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer usoóa enta óuma ento. Grove Seeed Sensor Mezzanine- ის ინსტალაცია DRAGONBOARD 410c- ში, რომელიც შეიძლება იყოს microcontrolador ATmega 328, არ არის შესაძლებელი პროცესორის დასაწყებად.

O Arduino DUE foi configurado para receber os comandos enviados da plataforma QUALCOMM DRAGONBOARD 410c კომუნიკაციის სერიის საშუალებით.

როგორც ações configuradas არ Arduino foram:

Realizar a aquisição dos dados;

გადააადგილეთ DRAGONBOARD 410c– სთვის;

აირჩიეთ პროგრამული უზრუნველყოფა:

#მოიცავს #განსაზღვრეთ Numb_Sample 3000 #განსაზღვრეთ DAC_Input A0

#განსაზღვრეთ SERVO 7

#განსაზღვრეთ PosServoMin 4 #განსაზღვრეთ PosServoMax 6 #განსაზღვრეთ პერიოდი 60 ხელმოუწერელი int Scont = 0, SNow = PosServoMin; unsigned long int DAC [Numb_Sample], ind = Numb_Sample; ბათილია 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 (irq); // habilita interrupção}

ბათილად დაყენება ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // ტაიმერის დაწყება // TC_Stop (TC1, 0); pinMode (SERVO, OUTPUT); }

ბათილი მარყუჟი ()

{/*// ხოლო (! Serial.available ()); char rc; // = Serial.read (); int ინდექსი = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); გადართვა (rc) {შემთხვევა 1: ინდექსი = 0; ხოლო (! სერიული. ხელმისაწვდომი ()); ხოლო ((rc = Serial.read ())! = 0xFF) {ინდექსი << = 8; ინდექსი += rc; ხოლო (! სერიული. ხელმისაწვდომი ()); } Serial.print (0); სერიული. ბეჭდვა (2); SendNumber (DAC [ინდექსი]); Serial.print (0xFF); შესვენება; შემთხვევა 3: ხოლო (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; დაგვიანება (500); ind = 0; // TC_Start (TC1, 0); ხოლო (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; დაგვიანება (500); Serial.print (0); სერიული. ბეჭდვა (4); Serial.print (0xFF); } შესვენება; }} else if (rc == '2') {Serial.print ("ტესტი Servo Motor / n"); ხოლო (! სერიული. ხელმისაწვდომი ()); 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: ინტერფეისები Das Tecnologias

იმისათვის, რომ შეაერთოთ ფაილები, შეგიძლიათ გამოიყენოთ Dragon და DRAGONBOARD 410c, გამოიყენეთ ინტერფეისი, რომელიც საშუალებას მოგცემთ გამოიყენოთ შემსრულებელი, ასევე გამოიყენოთ USB CDC ინტერფეისი, Arduino DUE და DRCONBOARD 410 აუცილებლობა გირჩევთ გააკეთოთ KERNEL da DRAGONBOARD 410c, რაც არ არის გამორიცხული, რომ გამოიწვიოს ტემპის გაფრქვევა.

ნაბიჯი 7: კონფიგურაცია DRAGONBOARD 410c (პითონი)

Foi configurada para enviar ao Arduino DUE os comandos para realizar a aquisição de dados e transmitir os dados obtidos. Segue código abaixo.

დაკვირვება: არამიზნობრივი გამოყენება არ არის გამოყენებული, არ არსებობს ფუნქცია, რომ გამოიყენოთ არანორმალური გამოყენების შესაძლებლობები არანდინო DUE e o Mezzanine serem შეუსაბამობა. USB– ის საშუალებით შეგიძლიათ გამოიყენოთ USB კავშირი, რაც აუცილებელია KERNEL– ის DRAGONBOARD 410c– სთვის, რათა გამოვიყენოთ კავშირის პორტატული გაფართოების კრიტერიუმი.

იმპორტი დრო იმპორტი სერიული იმპორტი პანდები როგორც pd იმპორტი numpy როგორც np

# კონფიგურაციის სერია

ser = serial. სერიული (პორტი = '/dev/ttyAMC0', #tty96B0 ', baudrate = 250000, parity = serial. PARITY_NONE, stopbits = serial. STOPBITS_ONE, bytesize = serial. EIGHTBITS)

ser.isOpen ()

ბეჭდვა ('შეიყვანეთ თქვენი ბრძანებები ქვემოთ. / 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) while (c! = 0xFF): atual << 8 atual += cc = ser.read (1) lista.append (atual)

ნაბიჯი 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez need a need 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 algoritmosos anosilosososososos nos algoritmos რა გააცნობიეროს, რომ ეს არის ჩვენი c algoritmo em PYTHON 3 que le o arquivo WAV e salva os dados do espectro em um arquivo CSV. Ogoritmo utilisado segue abaixo e em anexo para download.

ეს არის საჭირო იმისათვის, რომ შევასრულო სისტემის ფუნქციონირება, ეს არის Arduino DUE jw enviará esses dados em um array de valores numéricos.

# კოდირება: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

იმპორტის ტალღა იმპორტი numpy როგორც np იმპორტი pandas როგორც pd იმპორტი matplotlib.pyplot როგორც plt

# FUNÇÃO PARA CONVERTER 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) 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 (სიგნალი), pd. DataFrame (დრო)], ღერძი = 1) df.to_csv (ფაილის_სახელი + '.csv', ინდექსი = ყალბი) დაბრუნება df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

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

# GRÁFICO DO ESPECTRO DE AUDIO

ფიგურა, (ax1, ax2) = plt. ქვემოთხრობები (nrows = 2, ncols = 1, figsize = (20, 10)) ax1.plot (df_vazamento ['დრო'], 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 ['დრო'], 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: Análise Visual Do Sinal

როგორც PYTHON 3, ჩვენ ვაცნობიერებთ ფურიეს ტრანსფორმაციას, ეს არის ხელოვნური მატერიალური რეალიზება, რომელიც ახდენს სიხშირის დომინანტურ ცვლილებებს, რაც საშუალებას მოგცემთ გაანალიზოთ სხვადასხვა სიხშირის, ამპლიტუდისა და სიღრმისეული სიდიდე. ვიზუალურად ვიმსჯელებთ ფურიეს ტრანსფორმაციასთან და პროფესიულ პროფესიულ საქმიანობასთან ერთად, ვიმსჯელებთ ალტერნატიულ ვაზნებზე და მილაკებზე. Estes gráficos servirão para validação das análises realizadas pelo algoritmo de detecção automática.

შემოიფარგლება სიხშირეების სიხშირით 100Hz და 800Hz, ეს ნიშნავს, რომ არსებობს სიხშირეების შემდგომი გაფართოების შემდგომი არსებობა.

# კოდირება: utf-8# Moudulos utilisados para processamento da transformada de Fourier

იმპორტი pandas როგორც 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; # ინტერვალო de amostragem y = pd.concat (df_list) t = y ['დრო'] # ვეტერინარული ტემპები y = y ['amp'] # ვეტერინარული ამპლიტუდები n = len (y) # კომპრომეტირება 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]. ნაკვეთი (t, y) ax [0].set_xlabel ('დრო') ax [0].set_ylabel ('ამპლიტუდა') ax [1]. ნაკვეთი (frq, abs (Y), 'r') ax [1].set_xlim ([100, 800]) ax [1].set_ylim ([0, max_lim]) ax [1].set_xlabel ('Freq (Hz)') ax [1].set_ylabel ('| Y (freq) |') plt.show () return frq, abs (Y)# Função que realiza a carga dos dados do CSV and chama a função de funie de de Fourier def read_csv (file_name, init, final): df = pd.read_csv (ფაილის_სახელი + '.csv') df.columns = ['amp', ' დრო '] delta = final-init if init*44100> len (df) ან final*44100> len (df): init = (len (df)/44100) -delta if init = 100) & (df [' freq '] <= 800)] mx = დალაგებულია (df [' amp ']) ბეჭდვა ("Média das amplitudes:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudes.") print ("100 maiores amplitudes", np.mean (mx [-100:]) // df ['amp']. საშუალო ()*100, "%", sep = "") ბეჭდვა ("50 maiores amplitudes:", np.mean (mx [-50:]) // df ['amp']. საშუალო ()*100, "%", sep = "") ბეჭდვა ("10 maiores amplitudes:", np.mean (mx [-10:]) // df ['amp']. ნიშნავს ()*100, "%", sep = "") ბეჭდვა ("ძირითადი ამპლიტუდა:", np.mean (mx [-1:]) // df ['amp']. საშუალო ()*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

გამოვიყენოთ ის, რაც ჩვენ ვგულისხმობთ ჩვენს მახასიათებლებს (მახასიათებლები) dos dados obtidos.

ეს არის პირველადი რეალობა, რომელიც მოითხოვს დამატებით იდენტიფიკაციას, საჭიროებისამებრ, საბურთალომ შეიძლება შეაფასოს ის, რაც შეიძლება გამოყენებულ იქნეს, რადგან ეს არის ის, რაც შეიძლება გამოყენებულ იქნას როგორც მომსახურების გაწევისთვის, ასევე მისი გამოყენებისათვის.

იმის გათვალისწინებით, თუ როგორ მუშაობს ჩვენი ოპერაციული სისტემა, როდესაც ჩვენ ვმუშაობთ სხვადასხვა ოპერაციებში, ჩვენ არ გამოვიყენებთ დამატებით იდენტიფიკაციას, ვიზუალურად გამოვიყენებთ თვისებებს, რომლებიც ხასიათდება იმით.

არსებობს მახასიათებლები ou caraterísticas são propriedades acústicas compostas por varias informações referentes ao espectro de captudio capturado, abaixo seguirá uma descrição (em inglês) destas características.

ეს არის ის ნაწილი, რომელიც დაგვიკავშირდება არა GitHub– ით და გვთავაზობს წვდომას იმ ბმულზე, რომლითაც ჩვენ ვცდილობთ გამოვიყენოთ როგორც სპეციალური პროგრამები.

პროგრამული უზრუნველყოფის გამოყენებით, თქვენ უნდა გადმოწეროთ უფასოდ R, R სტუდია.

Características extraídas:

• საშუალო სიხშირე: საშუალო სიხშირე (kHz– ში)
• sd: სიხშირის სტანდარტული გადახრა
• მედიანა: მედიანური სიხშირე (kHz– ში)
• Q25: პირველი კვანტილი (kHz– ში)
• Q75: მესამე კვანტილი (kHz– ში)
• IQR: ინტერკვანტილური დიაპაზონი (kHz– ში)
• დახრა: დახრილობა (იხ. შენიშვნა სპეციფიკური აღწერილობისას)
• კურტი: კურტოზი (იხილეთ შენიშვნა სპეციფიკური აღწერილობაში)
• sp.ent: სპექტრალური ენტროპია
• sfm: სპექტრალური სიბრტყე
• რეჟიმი: რეჟიმის სიხშირე
• ცენტროიდი: სიხშირის ცენტროიდი (იხ. სპეციფიკა)
• პიკი: პიკის სიხშირე (სიხშირე უმაღლესი ენერგიით)
• meanfun: ფუნდამენტური სიხშირის საშუალო გაზომვა აკუსტიკური სიგნალის გასწვრივ
• minfun: მინიმალური ფუნდამენტური სიხშირე იზომება აკუსტიკური სიგნალის გასწვრივ
• maxfun: მაქსიმალური ფუნდამენტური სიხშირე იზომება აკუსტიკური სიგნალის გასწვრივ
• meandom: დომინანტური სიხშირის საშუალო გაზომვა აკუსტიკური სიგნალის გასწვრივ
• mindom: მინიმალური დომინანტური სიხშირის გაზომვა აკუსტიკური სიგნალის გასწვრივ
• maxdom: დომინანტური სიხშირის მაქსიმუმი, რომელიც იზომება აკუსტიკური სიგნალის გასწვრივ
• dfrange: დომინანტური სიხშირის დიაპაზონი იზომება აკუსტიკური სიგნალის გასწვრივ
• modindx: მოდულაციის ინდექსი. გამოითვლება, როგორც დაგროვილი აბსოლუტური განსხვავება ფუნდამენტური სიხშირის მიმდებარე გაზომვებს შორის, გაყოფილი სიხშირის დიაპაზონში
• ეტიკეტი: გაჟონვა ან გაჟონვის გარეშე

ალგორითმოს გამოყენება:

პაკეტები <- c ("tuneR", "seewave", "fftw", "caTools", "randomForest", "warbleR", "მაუსები", "e1071", "rpart", "xgboost", "e1071") თუ (სიგრძე (setdiff (პაკეტები, პაკეტები, პაკეტები ())))> 0) {install.packages (setdiff (პაკეტები, სახელები (დაინსტალირებული. პაკეტები ()))))}

ბიბლიოთეკა (tuneR)

ბიბლიოთეკა (seewave) ბიბლიოთეკა (caTools) ბიბლიოთეკა (rpart) ბიბლიოთეკა (rpart.plot) ბიბლიოთეკა (randomForest) ბიბლიოთეკა (warbleR) ბიბლიოთეკა (თაგვები) ბიბლიოთეკა (xgboost) ბიბლიოთეკა (e1071)

specan3 <- ფუნქცია (X, bp = c (0, 22), wl = 2048, ბარიერი = 5, პარალელური = 1) { # პარალელური დამუშავების გამოსაყენებლად: ბიბლიოთეკა (devtools), install_github ('nathanvan/parallellsugar') თუ (კლასი (X) == "data.frame") {if (ყველა (c ("sound.files", "selec", "start", "end") % % 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))} სხვა გაჩერება (ჩასვით (ჩასვით (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "დაწყება", "დასასრული") % % სვეტებში (X))], კოლაფსი = ","), "სვეტი (ები) არ არის ნაპოვნი მონაცემთა ჩარჩოში"))} else stop ("X არ არის მონაცემთა ჩარჩო") #თუ არსებობს NAs საწყისი ან ბოლო გაჩერების თუ (ნებისმიერი (is.na (c (დასასრული, დაწყება)))) stop ("NAs found in start and/or end") #თუ დასასრული ან დასაწყისი არ არის რიცხვითი გაჩერება if (ყველა (კლასი (დასასრული)! = "რიცხვითი" & კლასი (დაწყება)! = "რიცხვითი")) გაჩერება ("" დასასრული "და" შერჩევა "უნდა იყოს რიცხვითი") #თუ რომელიმე დასაწყისი უფრო მაღალია, ვიდრე დასასრული, თუ (ნებისმიერი (დასასრული - დაწყება <0)) გაჩერება (ჩასმა ("დასაწყისი უფრო მაღალია, ვიდრე en d in ", length (which (end - start20)) stop (paste (length (which (end - start> 20))," selection (s) უმეტეს 20 წამი ")) options (show.error.messages = TRUE) #თუ bp არ არის ვექტორი ან სიგრძე! = 2 გაჩერება თუ (! არის. ვექტორი (bp)) stop ("'bp' უნდა იყოს სიგრძის რიცხვითი ვექტორი 2") სხვაგან {if (! length (bp) == 2) გაჩერება ("'bp' უნდა იყოს რიცხვითი ვექტორი სიგრძის 2")} #დაბრუნების გაფრთხილება თუ ყველა ხმოვანი ფაილი არ იქნა ნაპოვნი fs <- list.files (path = getwd (), pattern = ".wav $", იგნორირება. შემთხვევა = TRUE) თუ (სიგრძე (უნიკალური (sound.files [(sound.files % in % fs)])))! = სიგრძე (უნიკალური (sound.files))) კატა (პასტა (სიგრძე (უნიკალური (ხმა) ფაილები))-სიგრძე (უნიკალური (sound.files [(sound.files % in % fs)]))), ".wav ფაილი (ები) ვერ მოიძებნა")) #სამუშაო დირექტორიაში ხმოვანი ფაილების #რაოდენობა და თუ 0 გაჩერება d <- რომელიც (sound.files % in % fs) if (length (d) == 0) {stop (".wav ფაილები არ არის სამუშაო დირექტორიაში")} სხვა {დაწყება <- დაწყება [d] დასასრული <- დასასრული [დ] სელეკი <- სელეკი [დ] ხმა. ფაილები <- ხმა. ფაილები [დ]} # თუ პარალელი არ არის რიცხვითი, თუ (! არის რიცხვითი (პარალელური)) გაჩერება ("პარალელი" უნდა იყოს რიცხვითი ვექტორი სიგრძის 1 ") თუ (რომელიმე (! (პარალელური %% 1 == 0), პარალელური 1) {პარამეტრები (გაფრთხილება = -1) თუ (ყველა (Sys.info () [1] ==" Windows ", requireNamespace (" parallellsugar ", მშვიდად = TRUE) == TRUE)) lapp <- ფუნქცია (X, FUN) parallellsugar:: mclapply (X, FUN, mc.cores = parallel) else if (Sys.info () [1] == "Windows") {cat ("Windows მომხმარებლებს უნდა დააყენონ" parallellsugar "პაკეტი პარალელური გამოთვლისთვის (თქვენ ამას ახლა არ აკეთებთ!)") Lapp <- pbapply:: pblapply} სხვა lapp <- ფუნქცია (X, FUN) პარალელური:: mclapply (X, FUN, mc.cores = პარალელი)} else lapp <- pbapply:: pblapply პარამეტრები (გააფრთხილე = 0) თუ (პარალელური == 1) კატა ("აკუსტიკური პარამეტრების გაზომვა:") x <- as.data.frame (lapp (1: სიგრძე (დაწყება)), ფუნქცია (i) {r <- tuneR:: readWave (file.path (getwd (), sound.files ), ეხლა = დაწყება , = დასრულება , ერთეულები = "წამი") b ჭერი ([email protected]/2000) - 1) b [2] < - ჭერი ([email protected]/2000) - 1 #სიხშირის სპექტრის ანალიზი songspec <- seewave:: spec (r, f = [email protected], plot = FALSE) analysis <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), ნაკვეთი = FALSE) #პარამეტრების შენახვა meanfreq <- ანალიზი $ საშუალო/1000 sd <- ანალიზი $ sd/1000 მედიანა <- ანალიზი $ მედიანა/1000 Q25 < - ანალიზი $ QQ75 <- ანალიზი $ QIQR <- ანალიზი $ IQR/1000 გადახრა <- ანალიზი $ გადახრის კურტი <- ანალიზი $ კურტოზი sp.ent <- ანალიზი $ შ სფმ <- ანალიზი $ სფმ რეჟიმი <- ანალიზი $ რეჟიმი/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, threshold = threshold, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] meanfun <-მნიშვნელობა (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #დომინანტური სიხშირის პარამეტრები y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, ნაკვეთი = F, ბარიერი = ბარიერი, bandpass = b * 1000, fftw = TRUE) [, 2] მეანდომი <- საშუალო (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TRUE) dfrange <- (maxdom- mindom) ხანგრძლივობა <- (დასასრული - დაწყება ) #მოდულაციის ინდექსის გაანგარიშება იცვლება <- ვექტორი () for (j რომელშიც (! არის na (y))) {ცვლილება <- abs (y [j]- y [j + 1]) ცვლილებები <- დამატება (ცვლილებები, ცვლილებები)} თუ (mindom == maxdom) modindx <-0 სხვა მოდინდ <- ნიშნავს (ცვლილებები, na.rm = T)/dfrange #შენახვა შედეგების დაბრუნება (c (ხანგრძლივობა, საშუალო სიხშირე, sd, მედიანა, Q25, Q75, IQR, გადახრა, კურტი, sp.ent, sfm, რეჟიმი, ცენტროიდი, პიკი, საშუალო გართობა, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #Change result სახელები rownames (x) <- c ("ხანგრძლივობა", "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 <- ფუნქცია (საქაღალდის სახელი) { # ცარიელი მონაცემებით დაწყება. ჩარჩო. მონაცემები <- data.frame () # მიიღეთ საქაღალდეში არსებული ფაილების სია. სია <- list.files (folderName, '\. wav') # დაამატეთ ფაილის სია data.frame დამუშავებისთვის. for (fileName in list) {row <- data.frame (fileName, 0, 0, 20) data <- rbind (data, row)} # სვეტების სახელების დაყენება სახელები (მონაცემები) <- c ('sound.files', 'selec', 'start', 'end') # გადატანა საქაღალდეში დამუშავებისათვის. setwd (საქაღალდის სახელი) # დამუშავების ფაილები. აკუსტიკა <- specan3 (მონაცემები, პარალელური = 1) # უკან დაბრუნება მშობლის საქაღალდეში. setwd ('..') აკუსტიკა}

gender <- ფუნქცია (filePath) {თუ (! არსებობს ('genderBoosted')) {load ('model.bin')} # დაყენების ბილიკები. currentPath <- getwd () fileName <- basename (filePath) path <- dirname (filePath) # დააყენეთ დირექტორია ფაილის წასაკითხად. setwd (გზა) # დაიწყეთ ცარიელი მონაცემებით. ჩარჩო. მონაცემები <- data.frame (ფაილის სახელი, 0, 0, 20) # დააყენეთ სვეტების სახელები. სახელები (მონაცემები) <- c ("sound.files", "selec", "start", "end") # დამუშავების ფაილები. აკუსტიკა <- specan3 (მონაცემები, პარალელური = 1) # აღდგენის გზა. setwd (მიმდინარე გზა) პროგნოზირება (genderCombo, newdata = აკუსტიკა)}

# მონაცემების ჩატვირთვა

გაჟონვა <- პროცესი ფოლდერი ("caminho para o pasta com sample de áudio com vazamento") გაჟონვის გარეშე <- processFolder ('caminho para o pasta com sample de áudio sem vazamento')

# დააყენეთ ეტიკეტები.

გაჟონვა $ label <- 1 გაჟონვის გარეშე $ label <- 2 მონაცემი <- rbind (გაჟონვა, გაჟონვის გარეშე) მონაცემები $ label <- ფაქტორი (მონაცემები $ label, labels = c ("გაჟონვა", "გაჟონვის გარეშე"))

# ამოიღეთ გამოუყენებელი სვეტები.

მონაცემები $ ხანგრძლივობა <- NULL მონაცემები $ sound.files <- NULL მონაცემები $ სელექცია <- NULL მონაცემები $ პიქფი <- NULL

# ამოიღეთ სტრიქონები, რომლებიც შეიცავს NA- ს.

მონაცემები <- მონაცემები [სრული. შემთხვევები (მონაცემები),]

# ჩაწერეთ csv მონაცემთა ნაკრები.

write.csv (მონაცემები, ფაილი = 'features.csv', sep = ',', row.names = F)

ნაბიჯი 11: გაათავისუფლეთ ნერვული

იდეალურია გამოიყენოს ნერვული სისტემა, ეს არის რეალიზება და რეკონსტრუქცია ავტომატიზირებულია através dos dados coletados pelo dispositivo de sensoriamento.

ნერვული სისტემის გამოყენება MLP (მრავალ ფენის Perceptron), ეს არის ის მოდელი, რომელიც ემსახურება იმ მოდელის იმპლანტაციას, რომელსაც არ გააჩნია სისტემური სისტემა, რომლის საშუალებითაც შესაძლებელია ავტომატური განხორციელება სინალის მიღებით, ინფორმაციის მიღებით.

Foi needário realizar uma filtragem dos dados de entrada, pois algumas características estavam diminuindo taxa de acerto da rede ao invés de melhora-la. არ ვიცი, თუ როგორ გავაცნობიერო ეს სტატუსი muito aprofundada, mas mesmo com um trabalho mais ზედაპირული pode-se chegar a algumas variáveis com bons desempenhos.

მოდელებმა შეაფასეს თქვენი მოდელი, რომლითაც შეგიძლიათ გამოიყენოთ 100%-იანი მაჩვენებელი, გამოვიყენოთ 100%-იანი მაჩვენებელი, გამოვიყენოთ გამოსახულება.

ეს არის ის, რაც გამოიყენება სამი მოდელისა და მოდელისთვის, რათა გადავიტანოთ ტაქსოს აერცეტი. არ არსებობს სისტემური მეთოდები, რომლებიც შეიძლება გამოყენებულ იქნას სხვადასხვა სახის სერვისებში, ჩვენ შეგვიძლია განვსაზღვროთ ის, თუ როგორ მივიღებთ მოდელს და როგორ გავაცნობიეროთ ის, თუ როგორ გავაცნობიეროთ ის წინამორბედ დონეზე.

# კოდირება: utf-8

შემოიტანეთ პანდები როგორც pd

იმპორტის numpy როგორც np საწყისი sklearn.model_selection იმპორტი მატარებელი_ტესტი_სპლიტი როგორც tts საწყისი sklearn.neural_network იმპორტი MLP კლასიფიკატორი MLP- დან sklearn.metrics იმპორტი კლასიფიკაცია_მოხსნა როგორც cr საწყისი sklearn.metrics იმპორტი confusion_matrix როგორც სმ

# Leitura dos dados do CSV

df = pd.read_csv ('features.csv') # ცალკე 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, სწავლის_რეინით = 0.0001, ფარული_ფენის_ზომები = (50, 50, 50, 50), max_iter = 10000, გააქტიურება = 'tanh', solver = 'lbfgs')

# ტრენანდო მოდელი

modelo.fit (X_train, Y_train) შედეგი = modelo.predict (X_test)

# შედეგი

ანგარიში = cr (Y_test, result) mat = cm (y_pred = result, y_true = Y_test) print ("Matriz de confusão") print (mat, end = "\ n / n") print ("Relatório de Classificação") print (ანგარიში)