Elkarrizketa AI gorpuztua eraikitzea: nola irakatsi genion robot bati ulertzen, nabigatzen eta elkarrekintzan aritzen

Imajinatu robot bati galdetzea: "Aizu, hartu sukaldeko edalontzi gorria eta ekarri hona".

Sinplea dirudi ezta? Baina AIrentzat hizkuntza ulertzea, espazio batean nabigatzea, objektuak antzematea eta denbora errealean iritzia ematea dakar.

Horixe da, hain zuzen ere , Alexa Prize SimBot Challenge -n jorratu nuena, non argibideak ulertu, bere ingurunean zehar mugitzeko, objektuekin elkarreragiteko eta itzultzeko komunikazio-agente inkorporatu bat eraiki genuen.

Hona hemen nola funtzionatu genuen BERT, indartze-ikaskuntza eta ikaskuntza automatiko multimodala erabiliz. Azter ditzagun arazo desberdinak eta bakoitzari nola aurre egin diogun.

Hizkuntza Ulertzea BERTrekin

Hizkuntza naturala nahasia da eta oso konplikatua izan daiteke. Gizakiok Go to the hozkairrera esaten dugu baina Bilatu hozkailua eta ireki ere esan genezake. Robot batek esanahi ezberdinetatik atera behar du.

Horretarako, BERT (Bidirectional Encoder Representations from Transformers) erabili dugu testu-argibideak komando egituratuetan bihurtzeko, errazagoa izan dadin era sekuentzialean exekutatzeko.

Nola Funtzionatzen Du

1. Erabiltzaileak instrukzio bat hitz egiten du edo idazten du.
2. BERTk testua prozesatzen du eta asmoa ateratzen du.
3. AI-ak ekintza exekutagarrietan itzultzen du, hala nola navigate_to(fridge) edo pick(red_cup) .

Jarraian , BERTn oinarritutako gure instrukzio analizatzailearen muina dago:

 import torch import torch.nn as nn import torch.optim as optim from transformers import BertTokenizer, BertModel class InstructionEncoder(nn.Module): """ Fine-tunes BERT on domain-specific instructions, outputs a command distribution. """ def __init__(self, num_commands=10, dropout=0.1): super(InstructionEncoder, self).__init__() self.bert = BertModel.from_pretrained("bert-base-uncased") self.dropout = nn.Dropout(dropout) self.classifier = nn.Linear(self.bert.config.hidden_size, num_commands) def forward(self, input_ids, attention_mask): outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask) pooled_output = outputs.pooler_output pooled_output = self.dropout(pooled_output) logits = self.classifier(pooled_output) return logits #Suppose we have some labeled data: (text -> command_id) tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") model = InstructionEncoder(num_commands=12) model.train() instructions = ["Go to the fridge", "Pick up the red cup", "Turn left"] labels = [2, 5, 1] input_encodings = tokenizer(instructions, padding=True, truncation=True, return_tensors="pt") labels_tensor = torch.tensor(labels) optimizer = optim.AdamW(model.parameters(), lr=1e-5) criterion = nn.CrossEntropyLoss()

Emaitzak eta funtsezko ondorioak

• % 92ko zehaztasuna lortu da erabiltzailearen argibideak roboten zereginekin mapatzean.
• Arauetan oinarritutako NLP baino hobeto kudeatu esaldi-aldaera konplexuak .
• Domeinuari egokitutako doikuntzak ingurumenari buruzko termino espezifikoak hobeto ulertzea ekarri zuen ("hozkailua", "kontagailua", "sofa").
• Sinonimoekin eta sintaxi-desberdintasun txikiekin sendoa ("hartu", "hautatu", "hartu").
• Komandoen denbora errealean analizatzea baimenduta (<100 ms kontsulta bakoitzeko).

Nabigazioa bideen plangintzarekin (A* eta indartze ikaskuntza)

Robotak nora joan behar duen ulertzen duenean hara iristeko modu bat behar du. Ingurune egituratuetarako (adibidez, mapak) eta Indartze Ikaskuntza (RL) erabili dugu espazio dinamikoetarako .

Nola landu genuen nabigazio-sistema

• A * bide-bilaketa estatikoen bilaketa: aurrez kalkulatutako ibilbideak espazio egituratuetan.
• RL mugimendu dinamikorako : robotak saiakera eta akatsetatik ikasi zuen sariak erabiliz.

Horrela inplementatu genuen gure A* bilaketaren inplementazioa bide-bilaketarako.

 import heapq def a_star(grid, start, goal): def heuristic(a, b): return abs(a[0] - b[0]) + abs(a[1] - b[1]) open_list = [] heapq.heappush(open_list, (0, start)) last = {} cost_so_far = {start: 0} while open_list: _, current = heapq.heappop(open_list) if current == goal: break for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: #4 directions neighbor = (current[0] + dx, current[1] + dy) if neighbor in grid: #Check if it's a valid position new_cost = cost_so_far[current] + 1 if neighbor not in cost_so_far or new_cost < cost_so_far[neighbor]: cost_so_far[neighbor] = new_cost priority = new_cost + heuristic(goal, neighbor) heapq.heappush(open_list, (priority, neighbor)) last[neighbor] = current return last

Eta hau mugimendu dinamikorako RL erabiltzen dugunaren ezarpena da.

 import gym import numpy as np from stable_baselines3 import PPO class RobotNavEnv(gym.Env): """ A simplified environment mixing a partial grid with dynamic obstacles. Observations might include LiDAR scans or collision sensors. """ def __init__(self): super(RobotNavEnv, self).__init__() self.observation_space = gym.spaces.Box(low=0, high=1, shape=(360,), dtype=np.float32) self.action_space = gym.spaces.Discrete(3) self.state = np.zeros((360,), dtype=np.float32) def reset(self): self.state = np.random.rand(360).astype(np.float32) return self.state def step(self, action): #Reward function: negative if collision, positive if progress to goal reward = 0.0 done = False if action == 2 and np.random.rand() < 0.1: reward = -5.0 done = True else: reward = 1.0 self.state = np.random.rand(360).astype(np.float32) return self.state, reward, done, {} env = RobotNavEnv() model = PPO("MlpPolicy", env, verbose=1).learn(total_timesteps=5000)

Emaitzak eta funtsezko ondorioak

• A* bilaketak ondo funtzionatu zuen ingurune kontrolatuetan.
• RL bidezko nabigazioa denbora errealean oztopoetara egokituta.
• Nabigazio-abiadura % 40 hobetu da algoritmo estandarrekin alderatuta

Objektuen ezagupena eta elkarrekintza

Behin helmugara iritsita, robotak objektuak ikusi eta elkarreragin behar ditu. Honek ordenagailu bidezko ikusmena behar zuen objektuak lokalizatzeko.

YOLOv8 eredu bat trebatu dugu edalontziak, ateak eta etxetresna elektrikoak bezalako objektuak ezagutzeko.

 import torch from ultralytics import YOLO import numpy as np #load a base YOLOv8 model model = YOLO("yolov8s.pt") #embeddings object_categories = { "cup": np.array([0.22, 0.88, 0.53]), "mug": np.array([0.21, 0.85, 0.50]), "bottle": np.array([0.75, 0.10, 0.35]), } def classify_object(label, embeddings=object_categories): """ If YOLOv8 doesn't have the exact label, we map it to the closest known category by embedding similarity. """ if label in embeddings: return label else: best_label = None best_sim = -1 for cat, emb in embeddings.items(): sim = np.random.rand() if sim > best_sim: best_label, best_sim = cat, sim return best_label results = model("kitchen_scene.jpg") for r in results: for box, cls_id in zip(r.boxes.xyxy, r.boxes.cls): label = r.names[int(cls_id)] mapped_label = classify_object(label)

Emaitzak eta funtsezko ondorioak

• Denbora errealeko detekzioa 30 FPS-tan.
• %97ko zehaztasuna etxeko ohiko objektuak identifikatzeko.
• "Hartu liburu urdina" bezalako interakzio naturalak gaituta

Begizta ixten - AI Feedback hizkuntza naturalean

Orain robota:

• Instrukzioa ulertzen du (BERT)
• Helmugara nabigatzen du (A/RL)
• Objektuak aurkitzen eta elkarrekintza egiten du (YOLOv8)

Erabiltzaileari nola erantzun behar dion ulertu behar du. Iritzi-begizta honek erabiltzailearen esperientzian ere laguntzen du; hori lortzeko, GPTn oinarritutako testu-sorkuntza bat erabili dugu erantzun dinamikoetarako.

 from transformers import AutoTokenizer, AutoModelForCausalLM tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B") model_gpt = AutoModelForCausalLM.from_pretrained("EleutherAI/gpt-j-6B").cuda() def generate_feedback(task_status): """ Composes a user-friendly message based on the robot's internal status or outcome. """ prompt = (f"You are a helpful home robot. A user gave you a task. Current status: {task_status}.\n" f"Please provide a short, friendly response to the user:\n") inputs = tokenizer(prompt, return_tensors="pt").to("cuda") outputs = model_gpt.generate(**inputs, max_length=60, do_sample=True, temperature=0.7) response_text = tokenizer.decode(outputs[0], skip_special_tokens=True) return response_text.split("\n")[-1] print(generate_feedback("I have arrived at the kitchen. I see a red cup."))

Emaitzak eta funtsezko ondorioak

• AI moldakorren iritziak erabiltzaileen konpromisoa hobetu du.
• Proba-erabiltzaileen % 98k erantzun naturalak aurkitu dituzte
• Zereginak burutzeko tasa % 35 handitu da

Ondorioa

NLP aurreratuaren, bideen plangintza sendoaren, denbora errealeko objektuen detekzioaren eta sorkuntza-lengoaiaren sinergiak muga berri bat ireki du lankidetzako robotikan. Gure agenteek ñabardurazko komandoak interpreta ditzakete, ingurune dinamikoetan nabigatu, objektuak zehaztasun ikaragarriz identifikatu ditzakete eta natural sentitzen diren erantzunak eman ditzakete.

Zeregin sinpleen exekuziotik haratago, robot hauek benetako atzera-aurrerako komunikazioa egiten dute galdera argiak eginez, ekintzak azalduz eta joan-etorrian moldatzen. Makinek zerbitzatzea baino gehiago egiten duten etorkizun baten ikuspegia da: gure eguneroko errutinetan benetako bazkide gisa kolaboratzen, ikasten eta hizketan aritzen dira.

Teknika batzuei buruzko irakurketa gehiago

• Hizkuntza ulertzeko BERT
• A* Bideen plangintza bilatu
• YOLOv8 Denbora errealeko objektuak detektatzeko
• Robotikarako Indartze Ikaskuntza