SO-100 పై ACT ని మొదటి నుండి ఎలా శిక్షణ ఇవ్వాలి

SO-100 పాలసీలలో ACT ప్రత్యేకమైనది. GR00T N1.7 మరియు N1.5 ప్రారంభమవుతాయి nvidia/GR00T-N1.7-3B మరియు nvidia/GR00T-N1.5-3B, Pi0.5 నుండి lerobot/pi05_base. ACT ఏమీ లేకుండా ప్రారంభమవుతుంది: దీనికి బేస్ చెక్‌పాయింట్ లేదు, ఎందుకంటే ఇది ఫౌండేషన్ మోడల్ కాదు. ఇది సుమారు 80 మిలియన్ పారామీటర్ల ట్రాన్స్‌ఫార్మర్, మీరు మీ చేతిపై, మీ లైటింగ్ కింద, ఒకే పని కోసం మొదటి నుండి శిక్షణ ఇస్తారు.

అందుకే ఇది 20 ms లో ఒక కంట్రోల్ స్టెప్‌ను నడుపుతుంది, అయితే 3 బిలియన్ పారామీటర్ల VLA కు 152 నుండి 485 ms అవసరం, మరియు ఒక్కో రన్‌కు 4 నుండి 12 USD బదులుగా 1 నుండి 3 USD ఖర్చవుతుంది. ఈ గైడ్ మాన్యువల్ మార్గాన్ని వివరిస్తుంది lerobot పై ఒక SO-100: రికార్డ్, act కాన్ఫిగ్, ఏమిటి chunk_size మరియు n_action_steps నియంత్రిస్తాయి, 100000 స్టెప్ షెడ్యూల్, రోల్‌అవుట్. ఆపై AY-Robots లో అదే పని, ప్లాట్‌ఫారమ్ సహాయం చేయని చోట కూడా.

ACT అంటే ఏమిటి

యాక్షన్ చంకింగ్ విత్ ట్రాన్స్‌ఫార్మర్స్ (ACT) ALOHA పేపర్ నుండి వచ్చింది, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, Zhao, కుమార్, లెవిన్ మరియు ఫిన్ ద్వారా, arXiv, 23 ఏప్రిల్ 2023. ఈ రిగ్ 50 Hz వద్ద రికార్డ్ చేస్తుంది, నాలుగు వెబ్‌క్యామ్‌లు 480x640 రిజల్యూషన్‌తో 30 fps వద్ద స్ట్రీమ్ చేస్తాయి: రెండు గ్రిప్పర్‌లపై, ఒకటి పైన, ఒకటి ముందు. 10 నిమిషాల ప్రదర్శనల నుండి, ఆరు నైపుణ్యాలలో 80 నుండి 90 శాతం విజయాన్ని సాధించినట్లు సారాంశం పేర్కొంది, వాటిలో పారదర్శక కండిమెంట్ కప్పును తెరవడం మరియు బ్యాటరీని స్లాట్ చేయడం ఉన్నాయి.

రికార్డింగ్ సెషన్‌ను ప్లాన్ చేసేటప్పుడు ఈ భాగం మరింత ఉపయోగకరంగా ఉంటుంది: ప్రతి పనికి 50 ప్రదర్శనలు, థ్రెడ్ వెల్క్రోకు 100 మినహా, ఇది 10 నుండి 20 నిమిషాల డేటా మరియు రీసెట్‌లను లెక్కించిన తర్వాత 30 నుండి 60 నిమిషాల వాల్-క్లాక్ సమయం. విజయం కూడా ఏకరీతిగా లేదు: థ్రెడ్ వెల్క్రో 20 శాతంతో ముగుస్తుంది, పుట్ ఆన్ షూ 92, కప్ ఓపెన్ 84, ప్రెప్ టేప్ 64.

యాక్షన్ చంకింగ్ అనేది మొత్తం ఆలోచన

సాధారణ ప్రవర్తనా క్లోనింగ్ ఒక పరిశీలనను ఒక చర్యకు మ్యాప్ చేస్తుంది, మరియు లోపాలు పెరుగుతాయి: ఒక విచలనం చేయిని పంపిణీ నుండి దూరం చేస్తుంది, చెత్త చర్యను ఉత్పత్తి చేస్తుంది, మరియు ముప్పై అడుగుల తర్వాత గ్రిప్పర్ వస్తువుకు దగ్గరగా ఉండదు. యాక్షన్ చంకింగ్ ఒకేసారి k చర్యలను అంచనా వేస్తుంది మరియు వాటిని అమలు చేస్తుంది, k కారకం ద్వారా సమర్థవంతమైన హోరిజోన్‌ను తగ్గిస్తుంది. ఇది మానవ డేటాకు ప్రత్యేకమైన ఒక సమస్యను కూడా నిర్వహిస్తుంది: టెలిఆపరేటర్లు పాజ్ చేస్తారు, మరియు ఒకే-దశ మార్కోవియన్ పాలసీ ముందు వచ్చిన దానిపై ఆధారపడిన పాజ్‌ను మోడల్ చేయదు.

పేపర్ kని నొక్కి చెప్పకుండా దానిని అబ్లేట్ చేస్తుంది. టెంపోరల్ ఎన్సెంబ్లింగ్ ఆఫ్ చేయబడినప్పుడు, నాలుగు సెట్టింగ్‌లలో సగటున, k = 1 వద్ద 1 శాతం నుండి k = 100 వద్ద 44 శాతానికి విజయం పెరుగుతుంది, ఆపై పాలసీ ఓపెన్-లూప్ నియంత్రణకు దగ్గరగా ఉన్నప్పుడు 200 మరియు 400 వద్ద తగ్గుతుంది. ఆ వక్రరేఖే డిఫాల్ట్ 100 కావడానికి కారణం.

• chunk_size: డీకోడర్ ప్రతి ఫార్వర్డ్ పాస్‌కు ఎన్ని భవిష్యత్ చర్యలను అంచనా వేస్తుంది. డిఫాల్ట్ 100.
• n_action_steps: మళ్లీ ప్రశ్నించే ముందు మీరు వాటిలో ఎన్నింటిని అమలు చేస్తారు. డిఫాల్ట్ 100, కాబట్టి lerobot మొత్తం చంక్‌ను ఓపెన్ లూప్‌లో నడుపుతుంది.
• లెరోబోట్ n_action_steps <= chunk_sizeను ధృవీకరిస్తుంది మరియు మీరు దాన్ని తప్పుగా ఇస్తే ValueErrorను పెంచుతుంది.

కార్యాచరణపరంగా ముఖ్యమైనది ఫ్రేమ్ రేట్ ద్వారా భాగించబడిన chunk_size. లెరోబోట్ యొక్క SO-100 ఉదాహరణలు ఉపయోగించే 30 fps వద్ద, 100 చర్యల చంక్ ఒక పరిశీలన నుండి సుమారు 3.3 సెకన్ల కాలాన్ని సూచిస్తుంది. ఆ విండోలో పనికి దిద్దుబాటు అవసరమైతే, తగ్గించండి n_action_steps, కాదు chunk_size: మీరు సుదీర్ఘ అంచనాను ఉంచుతారు మరియు తరచుగా మళ్లీ పరిశీలిస్తారు.

# predict 100 actions, re-query after 25 of them (about 0.8 s at 30 fps)
lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --policy.chunk_size=100 \
  --policy.n_action_steps=25 \
  --policy.device=cuda

ACT ఒక ఫౌండేషన్ మోడల్‌ను ఓడించినప్పుడు

ఐదు శిక్షణ పొందే విధానాలు పక్కపక్కన, AY-Robots కొలిచి, అద్దెకు తీసుకున్న GPU పరిమాణాన్ని నిర్ణయించడానికి ఉపయోగించే సంఖ్యలతో.

టాస్క్ మరియు సీన్ స్థిరంగా ఉన్నప్పుడు మరియు కదలిక వేగంగా మరియు ఖచ్చితంగా ఉండాల్సినప్పుడు ACTని ఎంచుకోండి. ఒక ఒక చెక్‌పాయింట్ అనేక సూచనలను కవర్ చేయాల్సినప్పుడు ఎంచుకోండి. రెండు పేజీలు నిర్ణయాన్ని తలపడి పని చేస్తాయి: మరియు . ప్రచురించబడిన బెంచ్‌మార్క్‌ల కోసం, ప్రతి సంఖ్యను దాని మూలానికి లింక్ చేస్తుంది.

మీరు ప్రారంభించడానికి ముందు మీకు ఏమి కావాలి

ఒక ఫాలోవర్ ఆర్మ్, కోసం ఒక లీడర్ ఆర్మ్, కనీసం ఒక కెమెరా, 24 GB GPU. ACT చిత్రాలను మరియు జాయింట్ పొజిషన్‌లను మాత్రమే చదువుతుంది. రెండు కెమెరాలు సరైనవి: వస్తువులు ఎక్కడ ఉన్నాయో చూపడానికి స్థిరమైన ముందు వీక్షణ, ఏమి తాకబోతోందో చూపడానికి ఒక మణికట్టు కెమెరా, ALOHAలో వలె.

ఖాళీ ఆర్మ్ నుండి రికార్డ్ చేయబడిన డేటాసెట్ వరకు

దిగువన ఉన్న ఫ్లో lerobot 0.6.x. మీకు కాలిబ్రేట్ చేయబడిన ఆర్మ్ మరియు డేటాసెట్ ఉంటే దీన్ని దాటవేయండి. లేకపోతే SO-100 ప్రారంభ గైడ్, అసెంబ్లీని కవర్ చేస్తుంది, రికార్డింగ్ వాక్‌త్రూ క్యాప్చర్‌ను కవర్ చేస్తుంది మరియు డేటాసెట్ డాక్యుమెంటేషన్ ఫార్మాట్‌ను కవర్ చేస్తుంది.

1. 1
   సరైన అదనపు ఫీచర్లతో లెరోబోట్‌ను ఇన్‌స్టాల్ చేయండి

   రికార్డింగ్ కోసం core_scripts, శిక్షణ కోసం training, Feetech సర్వోల కోసం feetech అవసరం. పైథాన్ 3.12+.

   bash

   conda create -y -n lerobot python=3.12
   conda activate lerobot
   conda install ffmpeg -c conda-forge
   
   pip install 'lerobot[core_scripts,training,feetech]'
   lerobot-info

2. 2
   ప్రతి చేయి యొక్క USB పోర్ట్‌ను కనుగొనండి

   రెండు చేతులను ప్లగ్ చేసి, అడిగినప్పుడు ఒకదాన్ని అన్‌ప్లగ్ చేయండి. లైనక్స్‌లో మీరు నోడ్ అనుమతులను తెరవాల్సి రావచ్చు.

   bash

   lerobot-find-port
   # on Linux, if the port exists but is unreadable:
   sudo chmod 666 /dev/ttyACM0

3. 3
   మోటారు ఐడిలు మరియు బాడ్‌రేట్‌ను సెట్ చేయండి

   SO-100లో ఇది అసెంబ్లీకి ముందు జరుగుతుంది: SO-101 వలె కాకుండా, ఒకసారి నిర్మించిన తర్వాత కనెక్టర్లు అందుబాటులో ఉండవు. స్క్రిప్ట్ గ్రిప్పర్ నుండి ఒక మోటారును ఒకేసారి బస్సులో నడుపుతుంది, EEPROMకి ఐడిలను వ్రాస్తుంది.

   bash

   lerobot-setup-motors \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0
   
   lerobot-setup-motors \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1

4. 4
   రెండు చేతులను కాలిబ్రేట్ చేయండి

   ప్రతి జాయింట్‌ను దాని పరిధి మధ్యలో సెట్ చేయండి, ఎంటర్ నొక్కండి, ఆపై ప్రతిదాన్ని దాని పూర్తి పరిధిలో స్వీప్ చేయండి. కాలిబ్రేషన్ ఒక చేయిపై శిక్షణ పొందిన పాలసీని మరొక దానిపై అమలు చేయడానికి అనుమతిస్తుంది. అదే idని తిరిగి ఉపయోగించండి.

   bash

   lerobot-calibrate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower
   
   lerobot-calibrate \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader

5. 5
   కెమెరాలను ఆన్ చేసి ఒకసారి టెలిఆపరేట్ చేయండి

   లెరోబోట్ యొక్క సాధారణ నియమం: మీరు కెమెరా చిత్రాలను మాత్రమే చూస్తూ పనిని చేయగలగాలి. మీరు చేయలేకపోతే, ACT కూడా చేయలేదు. ఇది తదుపరి డీబగ్గింగ్ కంటే ఎక్కువ చెడ్డ డేటాసెట్‌లను పట్టుకుంటుంది.

   bash

   lerobot-teleoperate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --display_data=true

6. 6
   50 ఎపిసోడ్‌లను రికార్డ్ చేయండి

   50 అనేది AY-Robots కనిష్ట సంఖ్య మరియు ALOHA ప్రతి పనికి ఉపయోగించినది. లెరోబోట్ ప్రతి వస్తువు స్థానానికి 10, కెమెరాలు స్థిరంగా, పట్టు స్థిరంగా ఉండాలని సలహా ఇస్తుంది. n ఒక ఎపిసోడ్‌ను ముగిస్తుంది, r తిరిగి రికార్డ్ చేస్తుంది, q ఆపి ఎన్‌కోడ్ చేస్తుంది.

   bash

   HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')
   
   lerobot-record \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --dataset.repo_id=${HF_USER}/so100_cube \
       --dataset.num_episodes=50 \
       --dataset.single_task="Grab the black cube and put it in the bin" \
       --display_data=true

శిక్షణకు ముందు, కనీసం ఐదు ఎపిసోడ్‌లను రీప్లే చేయండి. లెరోబోట్ డేటాసెట్ ఫార్మాట్ కెమెరా స్ట్రీమ్‌లు, జాయింట్ స్టేట్‌లు మరియు చర్యలను నిల్వ చేస్తుంది ఎపిసోడ్, మరియు రీప్లే ఆ చర్యలను తిరిగి చేయికి పంపుతుంది. రీప్లే పనిని చేయకపోతే, డేటా దానిని కలిగి ఉండదు మరియు శిక్షణ దానిని కనుగొనదు.

lerobot-replay \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower \
    --dataset.repo_id=${HF_USER}/so100_cube \
    --dataset.episode=0

ACT పాలసీకి శిక్షణ ఇవ్వడం

ఇది మొత్తం కమాండ్. ACT-నిర్దిష్టమైన ప్రతిదీ ఇప్పటికే డిఫాల్ట్‌గా ఉంది, అందుకే lerobot ACT పేజీ వాటితో ప్రారంభించమని చెబుతుంది.

lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --output_dir=outputs/train/act_so100_cube \
  --job_name=act_so100_cube \
  --policy.device=cuda \
  --wandb.enable=true \
  --policy.repo_id=${HF_USER}/act_so100_cube

--policy.type=act ACTConfigను లోడ్ చేస్తుంది, ఇది మీ డేటాసెట్ రికార్డ్ చేసిన మోటార్లు మరియు కెమెరాల సంఖ్యకు అనుగుణంగా ఉంటుంది, కాబట్టి మీరు అబ్జర్వేషన్ షేప్‌ను ఎప్పుడూ డిక్లేర్ చేయరు. --wandb.enable=true ఐచ్ఛికం మరియు విలువైనది: 100000 స్టెప్ రన్‌లో లాస్ కర్వ్ మాత్రమే చౌకైన సిగ్నల్. షెడ్యూల్ ACTConfig నుండి కాకుండా లెరోబోట్ యొక్క ట్రైన్ కాన్ఫిగ్ నుండి వస్తుంది: 100000 స్టెప్‌లు, బ్యాచ్ 8, సీడ్ 1000, ప్రతి 20000 స్టెప్‌లకు ఒక చెక్‌పాయింట్, ప్రతి 200కి లాగింగ్.

ఒక పూర్తి రన్ ఐదు చెక్‌పాయింట్ డైరెక్టరీలను వదిలివేస్తుంది, 020000 నుండి 100000 వరకు, ప్లస్ ఒక last సిమ్‌లింక్. వాటన్నింటినీ ఉంచండి: ఉత్తమ పాలసీ తరచుగా చివరిది కాదు.

వ్యవధి: పేపర్‌లో 11 GB RTX 2080 Ti పై సుమారు 5 గంటలు, lerobot యొక్క ACT పేజీ ప్రకారం 100k స్టెప్‌లకు కొన్ని గంటలు, AY-Robots 24 GB టియర్‌లో 2 నుండి 5 గంటలు. దీనిని తగ్గించవద్దు. రిఫరెన్స్ రెపో యొక్క README ప్రకారం, ఒక జెర్కీ లేదా పాజ్ అయ్యే పాలసీకి సాధారణంగా మరింత శిక్షణ, ఎందుకంటే లాస్ ప్లాటూస్ తర్వాత విజయం మరియు సున్నితత్వం మెరుగుపడుతూనే ఉంటాయి: వాస్తవ ప్రపంచ డేటా కోసం ఇది కనీసం 5000 ఎపోచ్‌లను కోరుకుంటుంది, లేదా ప్లాటూ తర్వాత మళ్లీ 3 నుండి 4 రెట్లు ఎక్కువ సమయం.

lerobot-train \
  --config_path=outputs/train/act_so100_cube/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

చేతిపై శిక్షణ పొందిన పాలసీని అమలు చేయడం

డిప్లాయ్‌మెంట్ ఉపయోగిస్తుంది lerobot-rollout. కెమెరా కీలు రికార్డ్ చేయబడిన వాటితో సరిపోలాలి: front మరియు wrist పై శిక్షణ పొందిన పాలసీ cam0 మరియు cam1 ను అంగీకరించదు, మరియు rename_map సహాయపడదు, ఎందుకంటే దీనికి ప్రీట్రైన్డ్ చెక్‌పాయింట్ అవసరం. టాస్క్ స్ట్రింగ్‌ను వదిలివేయవచ్చు; lerobot యొక్క స్వంత ఉదాహరణ ACT కోసం దీనిని స్కిప్ చేయదగినదిగా సూచిస్తుంది.

lerobot-rollout \
  --strategy.type=base \
  --policy.path=${HF_USER}/act_so100_cube \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
  --display_data=true \
  --duration=60

చివరి మోడల్‌కు బదులుగా ఒక చెక్‌పాయింట్‌ను పిన్ చేయడానికి, --policy.pretrained_revision. దానికి రన్ --save_checkpoint_to_hub=true, డిఫాల్ట్‌గా ఆఫ్ చేయబడింది: అది లేకుండా lerobot చివరి మోడల్‌ను మాత్రమే పుష్ చేస్తుంది. దానితో, ప్రతి చెక్‌పాయింట్ దాని జీరో-ప్యాడెడ్ స్టెప్‌తో ట్యాగ్ చేయబడుతుంది, కాబట్టి --policy.pretrained_revision=060000 60000వ స్టెప్ దానిని తిరిగి పొందుతుంది. నిజమైన ఆర్మ్‌పై దానిని 100000తో పోల్చడం అనేది అందుబాటులో ఉన్న చౌకైన ప్రయోగం.

ఒకే చెక్‌పాయింట్‌కు రెండు మార్గాలు

పైన పేర్కొన్నవన్నీ మాన్యువల్ మార్గం మరియు అది పని చేస్తుంది. ప్లాట్‌ఫారమ్ మార్గం GPU లేదా పైథాన్ ఎన్విరాన్‌మెంట్‌ను కలిగి ఉండకుండా నియంత్రణను వదులుకుంటుంది.

# the two commands that matter, end to end
lerobot-record --robot.type=so100_follower --robot.port=/dev/ttyACM0 \
  --teleop.type=so100_leader --teleop.port=/dev/ttyACM1 \
  --dataset.repo_id=${HF_USER}/so100_cube --dataset.num_episodes=50 \
  --dataset.single_task="Grab the black cube"

lerobot-train --dataset.repo_id=${HF_USER}/so100_cube --policy.type=act \
  --output_dir=outputs/train/act_so100_cube --policy.device=cuda

నిజానికి ఏమి తప్పు జరుగుతుంది

శిక్షణ కమాండ్‌లో దాదాపుగా ఎటువంటి సమస్య ఉండదు. సమస్య దాని చుట్టూ ఉన్న విషయాలలో ఉంటుంది, అవి మొదటిసారి ఎంత తరచుగా ఇబ్బంది పెడతాయో దాని ఆధారంగా క్రమబద్ధీకరించబడ్డాయి.

రెండు వరుసలు ప్రత్యేక శ్రద్ధకు అర్హమైనవి. ACT LeRobot v3.0లో శిక్షణ పొందుతుంది, అయితే GR00T యొక్క లోడర్ దానిపై క్రాష్ అవుతుంది మరియు v2.1 అవసరం, కాబట్టి ACTకి శిక్షణ ఇచ్చే డేటాసెట్ GR00T రన్‌ను విఫలం చేయగలదు. మరియు చివరి వరుసలో రెండు పరిష్కారాలు ఉన్నాయి: ACT రచయితలు అస్థిరమైన కదలికకు మరింత శిక్షణతో సమాధానం ఇస్తారు, అయితే n_action_steps 100 వద్ద, నిజమైన స్టాల్ ఒక చంక్ బౌండరీ వద్ద ఆగుతుంది, 30 fps వద్ద ప్రతి 3.3 సెకన్లకు ఒక స్పష్టమైన విరామం. తెలుసుకోవలసినవి మరో రెండు: ఒకే చనిపోయిన జాయింట్ సాధారణంగా ఎప్పుడూ వ్రాయబడని సర్వో ఐడి, మరియు దగ్గరకు వస్తుంది కానీ ఎప్పుడూ మూసివేయని గ్రిప్పర్ అంటే ప్రదర్శనలలో గ్రిప్పర్ పరిధి చాలా తక్కువ. పూర్తి సూచిక: వైఫల్య మోడ్ పేజీలు.

ఒక రన్ ఎంత ఖర్చవుతుంది

మీరు తర్వాత VLA కావాలనుకున్నా ACTతో ప్రారంభించడానికి ఇది ఒక వాదన. విఫలమైన ACT రన్ కాఫీ ధరతో సమానం మరియు మీ డేటాసెట్‌లో ఆ పని ఉందో లేదో కొన్ని గంటల్లో మీకు తెలియజేస్తుంది. విఫలమైన GR00T రన్ అదే పాఠం కోసం నాలుగు రెట్లు ఎక్కువ ఖర్చు అవుతుంది. తర్వాత GR00T N1.7 లేదా SmolVLAకి మారడం అనేది రూపంలో మార్పు, పునర్నిర్మాణం కాదు. నేపథ్యం: విజన్-లాంగ్వేజ్-యాక్షన్ మోడల్స్, SO-100 పూర్తి గైడ్, మీ మొదటి పాలసీని శిక్షణ ఇవ్వండి మరియు అనుకరణ అభ్యాసం. ఆర్మ్ లేదా? లైవ్ పేజీ సైన్ అప్ చేయకుండానే నిజమైన SO-100ని నడపడానికి స్ట్రీమ్ చేస్తుంది.