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 -n jorratu nuena, non argibideak ulertu, bere ingurunean zehar mugitzeko, objektuekin elkarreragiteko eta itzultzeko komunikazio-agente bat eraiki genuen. , Alexa Prize SimBot Challenge inkorporatu 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 esaten dugu baina Robot batek esanahi ezberdinetatik atera behar du. Go to the hozkairrera Bilatu hozkailua eta ireki ere esan genezake. Horretarako, BERT (Bidirectional Encoder Representations from Transformers) erabili dugu testu-argibideak komando egituratuetan bihurtzeko, errazagoa izan dadin era sekuentzialean exekutatzeko. Nola Funtzionatzen Du Erabiltzaileak instrukzio bat hitz egiten du edo idazten du. eta asmoa ateratzen du. BERTk testua prozesatzen du hala nola edo . AI-ak ekintza exekutagarrietan itzultzen du, navigate_to(fridge) 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 erabiltzailearen argibideak roboten zereginekin mapatzean. % 92ko zehaztasuna lortu da Arauetan oinarritutako NLP baino hobeto . kudeatu esaldi-aldaera konplexuak ingurumenari buruzko termino espezifikoak hobeto ulertzea ekarri zuen ("hozkailua", "kontagailua", "sofa"). Domeinuari egokitutako doikuntzak ("hartu", "hautatu", "hartu"). Sinonimoekin eta sintaxi-desberdintasun txikiekin sendoa Komandoen denbora errealean analizatzea baimenduta (<100 ms kontsulta bakoitzeko). Nabigazioa bideen plangintzarekin (A* eta indartze ikaskuntza) Robotak joan behar duen ulertzen duenean hara iristeko modu bat behar du. Ingurune (adibidez, mapak) eta Indartze Ikaskuntza (RL) dugu . nora egituratuetarako erabili espazio dinamikoetarako Nola landu genuen nabigazio-sistema * bide-bilaketa estatikoen bilaketa: aurrez kalkulatutako ibilbideak espazio egituratuetan. A : robotak saiakera eta akatsetatik ikasi zuen sariak erabiliz. RL mugimendu dinamikorako 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. eredu bat trebatu dugu edalontziak, ateak eta etxetresna elektrikoak bezalako objektuak ezagutzeko. YOLOv8 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. bezalako interakzio naturalak gaituta "Hartu liburu urdina" 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, bat erabili dugu erantzun dinamikoetarako. GPTn oinarritutako testu-sorkuntza 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
