Inteligența artificială (AI) și machine vision au un rol din ce în ce mai mare în procesarea digitală a imaginilor, având în vedere că software development-ul a deschis calea spre posibilități tehnologice complexe.
Următorul studiu elaborat de Victor, developer și inginer Embedded C/C ++ la AROBS și, în același timp, student pasionat la masterul de Automotive Embedded Software din cadrul Universității Politehnice din Timișoara, prezintă mecanismele și procesul creării unui braț robotic care poate tasta în mod autonom, utilizând rețele neuronale, machine vision și algoritmi de deep cam.
"Important este să nu te oprești din a te întreba."
Albert Einstein
Machine vision? Rețele neuronale? Detectarea obiectelor? Ce sunt toate astea? Cum funcționează? Și cea mai importantă întrebare: Cum le pot folosi în propriile proiecte pentru a automatiza diferite procese? Acestea au fost primele întrebări în domeniul machine vision și al rețelelor neuronale, pe care mi le-am pus ca student în ultimul an de licență, specializarea Automatizare și Informatică la Universitatea Tehnică din Moldova.
La fel ca toți studenții, m-am săturat să tastez text pe un computer, așa că motivat de spiritul meu de a automatiza diverse procese, mi-a venit ideea de a îmbina inteligența artificială, machine vision și alte tehnologii pentru a crea o mână robotică care tastează text, de mână, în mod autonom. Așa a luat naștere ideea lucrării mele de licență.
Principalele caracteristici ale unui sistem robotic inteligent
Conceptul de bază al proiectului se bazează pe utilizarea tehnicilor de machine vision, rețelelor neuronale, tehnicilor de poziționare în spațiul 3D prin camera WEB și, bineînțeles, crearea unui GUI (Graphical User Interface) pentru interacțiunea dintre sistemul inteligent și utilizator sau client.
Brațul robotului va transcrie automat textul scris de mână. Textul manual este vizualizat printr-o cameră WEB, după care este trimis la server pentru interpretarea și extragerea informației. După procesarea textului, brațul robotic echipat cu o altă cameră WEB, detectează literele de pe tastatură în timp real.
Prin utilizarea algoritmilor de deep cam, se urmărește traiectoria mișcării brațului de la punctul curent la litera necesară de pe tastatură. Acest proces se repetă ciclic pentru fiecare literă din cuvânt.
Pentru a interacționa mai confortabil cu utilizatorul, se creează un GUI (Figura 2), care oferă setul complet de caracteristici așteptate. Utilizatorul trebuie doar să plaseze textul sub cameră și să facă o fotografie prin intermediul acestei aplicații. După ce fotografia este făcută, aceasta este transmisă rețelelor neuronale ale serviciilor cognitive Microsoft (Figura 5 ). Această metodă a fost aleasă pentru a crește productivitatea și viteza programului. De asemenea, datorită acestor servicii, aceasta atinge o precizie de 90% a detectării textului (Figura 4). Comunicarea dintre programul de bază și Serviciile Cognitive Microsoft se efectuează prin API specializat( Figura 6), pentru setarea acestuia este nevoie de a crea cont special după care credențialele ca (user și parola să fie setate ca variabile globale în sistemul de operare, în cazul nostru este vorba despre Windows) (Figura 7).
Codul sursă al interfeței grafice:
self.stepOne =LabelFrame(self.Manual_Control_Tab,
text="Common Actions ")
self.stepOne.grid(row=1, columnspan=10,
sticky='W',padx=7, pady=5, ipadx=5, ipady=5)
..
self.robotic_frame =LabelFrame(
self.Manual_Control_Tab,
text=" Robotic Arm Control Block ")
self.robotic_frame.grid(row=3, columnspan=7,
sticky='W',padx=5, pady=5, ipadx=5, ipady=5)
self.entry_gcode_comands=Entry(
self.send_comand_frame,width=62)
self.entry_gcode_comands.grid(row=0,column =0)
..
Figura 2 - Graphical User Interface (GUI)
După ce textul este extras din imagine, acesta este transmis înapoi la algoritm, astfel încât să poată fi tastat de brațul robotic. Dar acesta este deja următorul pas.
Fotografia achiziționată prin intermediul camerei web este transformată într-o matrice (X, Y, Z) (Figura 3) unde X reprezintă - numărul de pixeli pe axa X, Y- numărul de pixeli pe axa Y, 3 - numărul de canale de culoare, în acest caz, RGB (roșu, verde, albastru). Pentru fiecare culoare, se formează o matrice bidimensională (X, Y) în care fiecare celulă cu coordonate (Jxy) reprezintă intensitatea pixelilor pentru fiecare canal separat.
După ce transformarea se realizează cu succes, fotografia este transmisă prin intermediul tehnologiei API (Application Programming Interface) către serverele Microsoft.
Codul sursă al modulului de comunicare cu Serviciile Cognitive Microsoft:
# Call the "GET" API and wait for the retrieval of
# the results
while True:
recognize_handwriting_result = self
.computervision_client
.get_read_operation_result(operation_id_local)
if recognize_handwriting_result.status
not in ['NotStarted', 'Running']:
break
time.sleep(1)
image = Image.open(local_image_handwritten_path)
ax = plt.imshow(image)
..Codul sursă al inițializării și verificării credențialelor de Microsoft Cognitive Services:
def initialize_cognitive_service(self,*args):
# Add and verify your Computer Vision subscription key to
# your environment variables.
if 'COMPUTER_VISION_SUBSCRIPTION_KEY' in
os.environ:
subscription_key = os.environ[
'COMPUTER_VISION_SUBSCRIPTION_KEY']
print("->FIND COMPUTER_VISION_SUBSCRIPT : OK")
else:
print("\nSet the COMPUTER_VISION_SUBSCRIPTION_
KEY environment variable.\n**Restart your shell or
IDE for changes to take effect.**")
os._exit(1)
# Add and verify your Computer Vision endpoint to your
# environment variables.
if 'COMPUTER_VISION_ENDPOINT' in os.environ:
endpoint = os.environ['COMPUTER_VISION_ENDPOINT']
print("->FIND COMPUTER_VISION_ENDPOINT : OK")
else:
..Interpretarea literelor de pe tastatură se face cu ajutorul rețelelor neuronale.
Rețeaua neuronală utilizată în acest proiect are rolul de a interpreta imaginea deja procesată de tehnologiile de procesare a imaginii digitale. Segmentarea imaginii se face independent, aceasta presupunând că imaginea transmisă pentru interpretarea rețelei neuronale poate fi doar o literă corespunzătoare unei singure clase de litere. Rețeaua neuronală utilizată în acest proiect are o viteză de procesare mult mai mare, viteza de detecție variind între 15-20ms.
Pasul 1: Achiziționarea prin intermediul WEB Cam a imaginii tastaturii.
Pasul 2: Binarizarea imaginii
Pasul 3: Segmentarea imaginii, pentru fiecare literă diferită
Pasul 4: Trimiterea imaginii din pasul anterior pentru interpretare către CNN (Convolutional Neuronal Networks)
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',
input_shape=input_shape))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(Dropout(0.2))
model.add(Conv2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(BatchNormalization())
model.add(Dropout(0.2))Inițializarea rețelei neuronale cu toate nivelurile necesare.
Pasul 5: Calcularea poziție literelor recunoscute în spațiul coordonatelor globale
print(":->Transform detected letter from 3D to 2D...")
global se
for c in loc:
x,y,w,h = loc[c]
pos_letter_list.append((c,x,y,w,h))
detectet_letter.append(c)
print("{}-{}".format(se,pos_letter_list[se]))
se = se+1
cx, cy = x+w/2, y+h/2
cx =cx +7
cy = cy +7
imgPt_c = np.array([[cx],[cy],[1 ]])
worldPt_c = k_inv.dot(depth_cam2key * imgPt_c)
centroid_dict[c] = (worldPt_c[0,0],
worldPt_c[1,0])
pos_dict[c] =(x,y,x+w,y+h,cx,cy,w,h)
detectet_letter.sort()
detectet_letter.pop(0)
print(":->OK.")Pasul 6: Obținerea răspunsului de ieșire de la CNN și decuparea fiecărei litere detectate de pe tastatură
În unele situații, din diverse motive, nu toate literele de pe tastatură sunt recunoscute. Algoritmul de inspecție vizuală este creat pentru a reduce apariția acestor situații. Scopul său principal este de a detecta litere care nu au fost recunoscute.
Această funcție este realizată prin utilizarea algoritmului care verifică iterativ fiecare literă recunoscută de rețeaua neuronală. Fiecare literă recunoscută este adăugată la o bază de date internă a programului. Prima etapă a algoritmului este de a compara baza de date curentă cu cea de referință (în această bază de date sunt prezente toate literele împreună cu literele vecine, litera vecină din dreapta și litera vecină din stânga), verificând și găsind litera care nu a fost recunoscută. Algoritmul folosește informațiile din baza de date curentă (literele recunoscute și poziția lor în spațiul 3D).
Codul sursă al algoritmului de inspecție vizuală:
print(":->Maping all detected letter...")
for i in detectet_letter:
sosed_r = sosedi[i][1]
sosde_l =sosedi[i][0]
if sosde_l ==" ":
ii = i in orderet_lt_dict
if ii == False:
not_detected_letter.append(i)
drawing_letter_pos.append(drawing_letter(i,
sosde_l,(0,0,0,0),sosed_r,"not_found"))
else:
ss = sosed_r in orderet_lt_dict
if ss == False:
print("------{}"
.format(sosed_r in orderet_lt_dict))
not_detected_letter.append(sosed_r)
drawing_letter_pos.append(drawing_letter(i,
sosde_l,(0,0,0,0),sosed_r,"not_found"))
else:
print("------{}"
.format(sosed_r in orderet_lt_dict))
drawing_letter_pos.append(drawing_letter(i,
sosde_l,(0,0,0,0),sosed_r,
orderet_lt_dict[sosed_r]))
..
Figura 9. Tasta recunoscută fără algoritmul de inspecție vizuală
Cartografierea literelor detectate de la tastatură se realizează în felul ilustrat în următoarea imagine:
Tastarea literelor de către brațul robotic se face prin legarea coordonatelor brațului robotic la coordonatele tastei corespunzătoare literei solicitate (Figura 11).
Această legare se face prin tehnici de fotometrie, care permite posibilitatea utilizării camerei web pentru a găsi poziția obiectului în sistemul de coordonate - global (X, Y, Z) prin manipularea cu imaginea corespunzătoare. Tehnica dată se numește Pin Hole Camera Model și se bazează pe modelul camerelor întunecate.
Aceasta tehnică funcționează pe baza proiectării punctului din sistemul global de coordonate pe planul imaginii. Aceasta realizează calculul distanței dintre două puncte. Cunoașterea poziției tastei și a brațului robotic face posibilă efectuarea calculelor necesare pentru a stabili traiectoria mișcării până la litera cerută (Figura 12).
Figura 12 - Modelul Pin Hole Camera utilizat pentru calcularea distanței dintre braț și literă de pe tastatură
Pentru a transforma coordonatele globale (X, Y, Z) în coordonatele (u, v) ale planului de imagine, este necesar să cunoaștem un set de parametri precum:
Unde:
fx - distanța focală pe axa x a camerei, măsurată în pixeli.
fy- distanța focală pe axa y a camerei măsurată în pixeli.
Coordonata Cx - x a centrului optic al camerei.
Coordonata Cy - y a centrului optic al camerei.
În urma calibrării camerei prin funcțiile din biblioteca OpenCV, se obține modelul camerei web utilizate în acest proiect.
Cunoscând parametrii necesari, se pot determina coordonatele globale ale punctului cu mare precizie, conform formulei de mai jos.
Figura 13. Rezultatul detectării utilizând Pinhole Camera Model
Figura 14. Precizia de calcul a algoritmului
Acest studiu demonstrează posibilitățile enorme ale inteligenței artificiale în procesarea digitală a imaginilor, oferind o gamă largă de variante posibile de utilizare în funcție de dorințele și nevoile inginerului.
Singurul dezavantaj este că necesită o bază materială tehnică modernă și resurse de calcul mari.
Machine vision este o ramură care este din ce în ce mai utilizată în toate domeniile vieții. Prin urmare, este o zonă de interes crescândă pentru studiile de cercetare ulterioare, care, în raport cu acest studiu, se vor concentra pe rezolvarea problemelor reale.
Pentru mai multe informații puteți lua legătura cu Victor P. scriindu-ne un mesaj.
Pentru a vedea cum funcționează brațul robotic, puteți viziona videoclipul de mai jos. (link)
Codul sursă al proiectului: https://github.com/JohnyLex/RoboticArm