PyBullet-basiertes Imitationslernen für den Roboterarm myCobot 320

In den letzten Jahren hat sich das bestärkende Lernen von Robotern rasant weiterentwickelt, wobei sich Imitationslernen als vielversprechender Ansatz herausgestellt hat. Diese Methode ermöglicht es Robotern, Aufgaben durch Beobachtung menschlicher Demonstrationen zu erlernen, was ein intuitiveres Training insbesondere in komplexen Umgebungen ermöglicht. Um den Lernprozess zu vereinfachen, führt Sie diese Anleitung durch die Implementierung von Imitationslernen für den 6-DOF myCobot 320 M5Stack mit PyBullet.

Wofür wird PyBullet verwendet?

PyBullet ist eine Physiksimulationsbibliothek, die in der Robotik häufig zur Erstellung virtueller Umgebungen eingesetzt wird. Sie bietet Werkzeuge zur Simulation der Roboterphysik und ihrer Interaktionen mit der Umgebung.

myCobot-Steuerung mithilfe eines vortrainierten Imitation-Learning-Modells

In diesem Projekt verwenden wir ein vortrainiertes Imitationslernmodell, um myCobot in einer simulierten Umgebung zu steuern. Wir verweisen auf das GitHub-Open-Source-Projekt von Sicelukwanda Zwane, der technischen Support leistete. Darüber hinaus hat Geraud Nangue Tasse, ein wichtiger Unterstützer des , maßgeblich zu diesem Projekt beigetragen.

Hauptfunktionen und Implementierung:

✅ Robotersimulation mit PyBullet – Simulation der Bewegungen von myCobot in einer virtuellen Umgebung.

✅ Imitation Learning Model Training – Dem Roboter beibringen, vordefinierte Aufgaben zu replizieren.

✅ Präzise Manipulationstechniken – Implementierung von Gelenkgeschwindigkeitskontrolle und inverser Kinematik für präzise Bewegungen.

✅ Echtzeitvisualisierung – Beobachten und Analysieren der Aktionen des Roboters in der Simulation.

Projekteinrichtung: Eine Schritt-für-Schritt-Anleitung

1. Einrichten der PyBullet-Simulation

Zuerst müssen wir den 6-Achsen-Roboterarm myCobot 320 in PyBullet laden und die physikalische Simulationsumgebung einrichten.

 
import pybullet as p
 import pybullet_data as pd
 import numpy as np
 import time

 # use PyBullet
 client_id = p.connect(p.GUI)
 p.setAdditionalSearchPath(pd.getDataPath())
 p.setGravity(0, 0, -9.8)

 # load 2 model a plane and a robot
 plane_id = p.loadURDF("plane.urdf")
 robot_id = p.loadURDF("mycobot_description/urdf/mycobot/mycobot_urdf.urdf", useFixedBase=True)

 # set step
 time_step = 1/240
 p.setTimeStep(time_step)

Alternativ können Sie die Roboterarmsimulation einfach mit dem von Sicelukwanda Zwane geschriebenen Code testen.

 
pip install pybullet numpy
 git clone https://github.com/Sicelukwanda/robot_learning_tutorial.gi 
CD Roboter-Lern-Tutorial
 python3 move_basic.py 

2. Sammeln Sie Demonstrationsdaten

Beim Imitationslernen müssen wir eine große Menge an Demonstrationsdaten sammeln, darunter:

• Zustand – Gelenkwinkel und Geschwindigkeit des Roboterarms.
• Aktion – der Zielgelenkwinkel oder die Zielgeschwindigkeit des Roboterarms.

Hier verwenden wir Pybullet, um den Status des Roboterarms abzurufen und einige Demonstrationsaktionen mit einfachem Code zu definieren.

 
states = []
 actions = []

 for i in range(100):
 joint_positions = [0, 0.3*np.sin(i/10), -np.pi/4, 0, np.pi/4, 0]
 states.append(joint_positions)
 actions.append(joint_positions) # In imitation learning, the ideal action is the correct state

 p.setJointMotorControlArray(robot_id, range(6), p.POSITION_CONTROL, targetPositions=joint_positions)
 p.stepSimulation()
 time.sleep(time_step)

 # save data
 np.save("states.npy", np.array(states))
 p.save("actions.npy", np.array(actions))

3. Training des Roboters

Wir müssen PyTorch installieren und mit dem Training eines neuronalen Netzwerkmodells beginnen.

import torch
import torch.nn as nn
import torch.optim as optim

# load 
X_train = np.load("states.npy")
y_train = np.load("actions.npy")

# trans to  PyTorch tensor
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.float32)

# load a simple network
class ImitationNetwork(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(ImitationNetwork, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, output_dim)
        )
    
    def forward(self, x):
        return self.model(x)

model = ImitationNetwork(input_dim=6, output_dim=6)
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_fn = nn.MSELoss()

# start training
epochs = 100
for epoch in range(epochs):
    optimizer.zero_grad()
    output = model(X_train)
    loss = loss_fn(output, y_train)
    loss.backward()
    optimizer.step() 
drucken(f"Epoche {Epoche+1}, Verlust: {loss.item():.4f}")

 # speichern
 torch.save(model.state_dict(), "imitation_model.pth")

4. Test

 
# Load your model
 model.load_state_dict(torch.load("imitation_model.pth"))
 model.eval()

 for i in range(100):
 joint_state = np.load("states.npy")[i]
 input_tensor = torch.tensor(joint_state, dtype=torch.float32).unsqueeze(0)
 predicted_action = model(input_tensor).detach().numpy().flatten()

 p.setJointMotorControlArray(robot_id, range(6), p.POSITION_CONTROL, targetPositions=predicted_action)
 p.stepSimulation()
 time.sleep(time_step)
 

Da die Bewegung des Roboterarms nicht manuell erfasst, sondern mithilfe von Code generiert wird, mangelt es ihm an Authentizität, was die Lernergebnisse beeinträchtigt. Daher kann der 6-achsige Roboterarm myCobot 320 M5Stack im praktischen Lernen bessere Bewegungsdaten erfassen.

Zusammenfassung

Diese Anleitung zeigt, wie Sie PyBullet für Imitationslernen mit myCobot-Roboterarmen verwenden, einschließlich Datenerfassung und -validierung.

In der Praxis können Sie dieses Tutorial wie folgt erweitern:

✅Verwendung fortgeschrittenerer neuronaler Netzwerke (wie LSTMs) zur Verarbeitung von Zeitreihendaten.

✅Integration von Reinforcement Learning (RL), um Robotern die autonome Optimierung ihres Verhaltens zu ermöglichen.

✅Anwenden der erlernten Strategien auf einen echten myCobot-Roboterarm.

Sie können versuchen, die Aufgabenziele zu ändern, indem Sie myCobot beispielsweise komplexere Vorgänge wie Pick-and-Place durchführen lassen. Wir freuen uns, wenn mehr Nutzer und Maker die Roboter der myCobot-Serie erkunden, um innovative Projekte zu entwickeln und an unserer Fallsammlungsaktion teilzunehmen.

Schaltpläne

Code: data_collection.pyPython

 
import pybullet as p
 import pybullet_data as pd
 import numpy as np
 import time

 # use PyBullet
 client_id = p.connect(p.GUI)
 p.setAdditionalSearchPath(pd.getDataPath())
 p.setGravity(0, 0, -9.8)

 # load 2 model a plane and a robot
 plane_id = p.loadURDF("plane.urdf")
 robot_id = p.loadURDF("mycobot_description/urdf/mycobot/mycobot_urdf.urdf", useFixedBase=True)

 # set step
 time_step = 1/240
 p.setTimeStep(time_step)

 states = []
 actions = []

 for i in range(100):
 joint_positions = [0, 0.3*np.sin(i/10), -np.pi/4, 0, np.pi/4, 0]
 states.append(joint_positions)
 actions.append(joint_positions) # In imitation learning, the ideal action is the correct state

 p.setJointMotorControlArray(robot_id, range(6), p.POSITION_CONTROL, targetPositions=joint_positions)
 p.stepSimulation()
 time.sleep(time_step)

 # save data 
np.save("states.npy", np.array(states))
 p.save("Aktionen.npy", np.array(Aktionen))