ඔබේම රොබෝ දත්ත මත Pi0.5 පුහුණු කරන්නේ කෙසේද

Pi0.5 යනු ප්‍රතිපත්තියක් කිසිදා නොදුටු කාමරයක ක්‍රියාත්මක විය යුතු විට ඔබ භාවිතා කරන ආකෘතියයි. එය මෙහි ඇති පුහුණු කළ හැකි ප්‍රතිපත්ති පහෙන් වඩාත්ම අපහසු එකකි අතින් සියුම්-සුසර කිරීමට: මක්නිසාද යත්, ඉහළ ධාරිතා ගබඩාව මුලින්ම JAX වන අතර, LeRobot port එක 0.6.0 හිදී lerobot-record වලින් deployment ඉවත් කර, මූලික ස්ථාපනය පුහුණු කිරීමට තරම් කුඩා කළ අතර, සම්පූර්ණ සියුම්-සුසර කිරීමක් 4090 එකකට නොගැලපේ. පහත දැක්වෙන්නේ: flow matching inference හිදී වැයවන ආකාරය, විධාන මාර්ග දෙක සහ ප්‍රතිඵලය භාවිතා කළ හැකිද යන්න තීරණය කරන 485 ms අගයයි.

Pi0.5 ඇත්ත වශයෙන්ම කුමක්ද

Physical Intelligence 2024 ඔක්තෝම්බර් මාසයේදී pi0 ප්‍රකාශයට පත් කළේය: එය pretrained VLM එකක් මත පදනම් වූ flow matching දෘශ්‍ය-භාෂා-ක්‍රියා ආකෘතියක් වේ. PaliGemma 3 බිලියන පරාමිති සහිත, සහ මුල සිටම ආරම්භ කරන ලද 300M ක්‍රියා විශේෂඥයෙකුගෙන් සමන්විත, මුළු බිලියන 3.3 ක ආකෘතියකි. මෙම පත්‍රිකාව රොබෝ වින්‍යාස 7ක් සහ කාර්යයන් 68ක් හරහා රොබෝ දත්ත පැය 10,000 කට අධික ප්‍රමාණයක් මත පූර්ව පුහුණුව වාර්තා කරයි. වැඩි විස්තර pi0 ලිපියෙන්.

Pi0.5 (arXiv 2504.16054, 22 April 2025) එම සැකිල්ල රඳවාගෙන පුහුණු කිරීමේ ආහාර රටාව වෙනස් කරයි: වෙබ් දත්ත, වස්තු හඳුනාගැනීම, රොබෝවරයාට පුහුණු කරන මිනිසුන්ගෙන් වාචික උපදෙස්, උපකාර්ය ලේබල, බොහෝ නිවෙස්වල ඇති රොබෝවරුන්ගෙන් හරස්-ශරීර දත්ත. එහි ප්‍රතිඵලය වන්නේ පුහුණු කට්ටලයේ නොතිබූ නිවෙස්වල මුළුතැන්ගෙවල් පිරිසිදු කරන රොබෝවරයෙකි. openpi README හි මාතෘකාවේ නොමැති විස්තරයක් එක් කරයි: නිකුත් කරන ලද pi0.5 දැනුම පරිවරණය (arXiv 2505.23705) සමඟ පුහුණු කර ඇත.

flow matching පුහුණු කිරීම සහ අනුමාන කිරීම ගැන වෙනස් කරන්නේ කුමක්ද

අ ප්‍රතිපත්තියක් ඔබට SO-100 මත පුහුණු කළ හැකි ක්‍රියා සෘජුවම ප්‍රතිගමනය කරයි (ACT) හෝ ඒවා ටෝකනයිස් කර ස්වයංක්‍රීයව විකේතනය කරයි (pi0-FAST). ප්‍රවාහ ගැලපීම මේ දෙකෙන් එකක්වත් නොකරයි: එය ශබ්දය පිරිසිදු ක්‍රියා කැබැල්ලකට, ඉන්පසු එය ඒකාබද්ධ කරයි. pi0 පත්‍රිකාව 0.1 පියවර ප්‍රමාණයෙන් ඒකාබද්ධ කිරීමේ පියවර 10ක් භාවිතා කරයි; LeRobot's pi05 config එකම `num_inference_steps: int = 10` දරයි.

• පුහුණුව: හානි වූ ක්‍රියා කැබැල්ලක් මත පාඩුව ප්‍රතිගමනය කරයි. සුසර කිරීමට ටෝකනයිසරයක් නැත, ඔබේ සන්ධි කෝණ විවික්තකරණයක් නැත.
• අනුමානය: එක් කැබැල්ලක් සඳහා ක්‍රියා විශේෂඥයා හරහා ඉදිරි ගමන් දහයක් වැය වේ. එය ව්‍යුහාත්මක වන අතර, සුසර කිරීමේ ගැටලුවක් නොවේ.
• ප්‍රතිදානය: අභ්‍යන්තරව පෑඩ් කරන ලද, මානය 32ක අඛණ්ඩ ක්‍රියා, ඔබේ රොබෝවරයා සතුව ඇති මානයන් මත පාඩුව ගනු ලැබේ. 6-DoF අතක් සහ ග්‍රිපරයක් 7ක් භාවිතා කරයි.

# openpi/src/openpi/models/pi0_config.py - the defaults every pi05 config inherits
@dataclasses.dataclass(frozen=True)
class Pi0Config(_model.BaseModelConfig):
    dtype: str = "bfloat16"
    paligemma_variant: _gemma.Variant = "gemma_2b"
    action_expert_variant: _gemma.Variant = "gemma_300m"

    action_dim: int = 32
    action_horizon: int = 50
    max_token_len: int = None      # 200 if pi05 else 48

    pi05: bool = False             # flips discrete_state_input to True

PaliGemma කොඳු නාරටිය සහ එය ඉදිරිපිට ඇති දොරටුව

PaliGemma (arXiv 2407.07726) යනු Gemma-2B භාෂා ආකෘතියක් මත පදනම් වූ SigLIP-So400m දෘශ්‍ය එන්කෝඩරයක් වන අතර, එය ආසන්න වශයෙන් 3B පරාමිති වලින් සමන්විත වේ. Pi0.5 එහි ටෝකනයිසර් උරුම කර ගන්නා අතර, එම ටෝකනයිසර් ගේට්ටු සහිත ගබඩාවක (gated repository) පිහිටා ඇත. පළමු ධාවනයක් (run) අසාර්ථක වීමට වඩාත් පොදු ක්‍රමය මෙයයි, පළමු පුහුණු පියවර ට පෙර.

ඔබ ආරම්භ කිරීමට පෙර: දත්ත කට්ටල ආකෘතිය, කථාංග, දෘඪාංග

LeRobot හි Pi0.5 කියවන්නේ LeRobot දත්ත කට්ටලයක් v3.0 සැකැස්මකින් යුත්, එය 2025 ඔක්තෝම්බර් මාසයේදී lerobot 0.4.0 සමඟ නිකුත් විය: එක් Parquet සහ MP4 ගොනුවකට කථාංග කිහිපයක්, එක් ගොනුවකට කථාංගයක් වෙනුවට, meta/episodes/ හි සීමා නිර්ණයන් සමඟින්. ඩෙස්ක්ටොප් සේවාදායකයා සමඟින් පටිගත කරන්න හෝ ඔබේ පළමු දත්ත කට්ටලය පටිගත කරන්න අනුගමනය කරන්න එවිට ඔබට එය ලැබෙනු ඇත.

# v2.1 -> v3.0, run against a dataset already on the Hub
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=<HF_USER/DATASET_ID>

# aggregates episode-0000.parquet, episode-0001.parquet, ... -> file-0000.parquet
# aggregates episode-0000.mp4, episode-0001.mp4, ...         -> file-0000.mp4
# rewrites meta/episodes/* with per-episode lengths, tasks and offsets

Pi0.5 සඳහා අවම වශයෙන් කථාංග 50ක් වේදිකාවට අවශ්‍ය වේ, එය GR00T සහ ACT සඳහා වන අවම සීමාවට සමාන වේ. පූර්ව පුහුණුව මගින් ප්‍රධාන කාර්යය සිදු කරයි, එබැවින් පිරිසිදු කථාංග 50ක් අවුල් සහගත කථාංග 200කට වඩා හොඳය. මේ සඳහා අලුත්ද? මෙයින් ආරම්භ කරන්න දත්ත එකතු කිරීමේ මාර්ගෝපදේශය

මාර්ගය A: openpi repository භාවිතයෙන් fine-tune කරන්න

යොමු ක්‍රියාත්මක කිරීම: මුලින්ම JAX, Ubuntu 22.04 මත පමණක් පරීක්ෂා කර ඇත, flags වෙනුවට config objects මගින් ධාවනය වේ. PyTorch මාර්ගයක් 2025 සැප්තැම්බර් මාසයේදී LIBERO මත වලංගු කරමින් පැමිණියේය. පියවර තුනක්: ඔබේ දත්ත පරිවර්තනය කරන්න, config එකක් නිර්වචනය කරන්න, පුහුණු කර සේවය කරන්න.

1. 1
   Clone කර ස්ථාපනය කරන්න

   openpi uv භාවිතා කරයි. GIT_LFS_SKIP_SMUDGE යනු LFS blobs නොමැතිව LeRobot dependency එකක් ලෙස පැමිණීමට ඉඩ සලසන දෙයයි.

   bash

   git clone --recurse-submodules git@github.com:Physical-Intelligence/openpi.git
   cd openpi
   
   GIT_LFS_SKIP_SMUDGE=1 uv sync
   GIT_LFS_SKIP_SMUDGE=1 uv pip install -e .

2. 2
   ඔබේ දත්ත LeRobot dataset එකක් බවට පරිවර්තනය කරන්න

   Upstream මගින් LIBERO සහ DROID සඳහා converters සපයන අතර, ඒවායින් එකක් අනුවර්තනය කිරීමට ඔබෙන් අපේක්ෂා කරයි. කාර්යය වන්නේ key mapping ය.

   bash

   uv run examples/libero/convert_libero_data_to_lerobot.py --data_dir /path/to/your/data

3. 3
   පුහුණු config එකක් එක් කරන්න

   Configs යනු src/openpi/training/config.py හි ඇති TrainConfig entries වේ. මෙය pi05_droid_finetune අනුවර්තනය කරයි, weight loader එක pi05_base වෙත යොමු කර ඇත.

   python

   TrainConfig(
       name="pi05_so100",
       model=pi0_config.Pi0Config(
           pi05=True,
           action_dim=32,        # pi05 is trained with 32-dim actions
           action_horizon=16,
       ),
       # Copy LeRobotLiberoDataConfig in the same file and rewrite the key
       # mapping for your camera names, then reference your copy here.
       data=LeRobotLiberoDataConfig(
           repo_id="your_hf_username/my_so100_dataset",
           base_config=DataConfig(prompt_from_task=True),
       ),
       weight_loader=weight_loaders.CheckpointWeightLoader(
           "gs://openpi-assets/checkpoints/pi05_base/params"
       ),
       batch_size=32,
       num_train_steps=20_000,
   )

4. 4
   සාමාන්‍ය සංඛ්‍යාන ගණනය කරන්න

   මෙය dataset එකට එරෙහිව නොව, config නාමයට එරෙහිව ධාවනය වේ. මෙය මඟ හැරීම මෙහි ඇති සාමාන්‍ය පළමු අසාර්ථකත්වයයි.

   bash

   uv run scripts/compute_norm_stats.py --config-name pi05_so100

5. 5
   පුහුණු කරන්න

   මෙම විචල්‍යය JAX හට පෙරනිමි 75 වෙනුවට GPU මතකයෙන් සියයට 90ක් භාවිතා කිරීමට ඉඩ සලසයි. 80 GB කාඩ්පතකදී, ධාවනය සාර්ථක වේද යන්න තීරණය කරන්නේ එයයි.

   bash

   XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_so100 \
       --exp-name=my_experiment \
       --overwrite

6. 6
   එය සේවය කරන්න

   සේවාදායකය port 8000 හි සවන් දෙන අතර observation queries වලට පිළිතුරු සපයයි; ඔබේ රොබෝ ධාවන කාලය සේවාදායකයා වේ.

   bash

   uv run scripts/serve_policy.py policy:checkpoint \
       --policy.config=pi05_so100 \
       --policy.dir=checkpoints/pi05_so100/my_experiment/20000

මාර්ගය B: lerobot pi05 සමඟ fine-tune කරන්න

ඔබ දැනටමත් භාවිතා කරන CLI හි LeRobot port එකම weights අසුරයි ACT සහ SmolVLA. පහත සියල්ල lerobot 0.6.1, 2026 අගෝස්තු 3 සිට නිකුත් වූ සංස්කරණය සහ 2026 අගෝස්තු 23 දිනැති pi05 docs සමඟ පරීක්ෂා කරන ලදී. මෙහිදී සංස්කරණ වැදගත් වේ: v3.0 දත්ත කට්ටල 2025 ඔක්තෝබර් මාසයේදී 0.4.0 සමඟ පැමිණියේය, 2026 මාර්තු 9 දිනැති 0.5.0 බ්ලොග් සටහන pi0-FAST සහ Real-Time Chunking ඉදිරිපත් කරයි, සහ 2026 ජූලි 6 දිනැති 0.6.0 මූලික පැකේජය සැහැල්ලු කර යෙදවීම lerobot-rollout වෙත ගෙන ගියේය.

එක් දෙයක් වෙනස් නොවීය: lerobot-train සහ lerobot-record දැනටමත් 2025 අගෝස්තු මාසයේදී 0.3.2 හි entry points විය. python -m lerobot.scripts.train තවමත් අමතන නිබන්ධනයක් වසරක වෙනස්කම් වලට පෙර පැවති එකක් වන අතර ඉතිරි දේ සම්බන්ධයෙන්ද විශ්වාස නොකළ යුතුය.

1. 1
   නිවැරදි අතිරේක සමඟ ස්ථාපනය කරන්න

   0.6.0 සිට මූලික ස්ථාපනය මූලික ML යැපීම් පමණක් දරන අතර, pi අතිරේකය කිසිදු දත්ත කට්ටලයක් හෝ පුහුණු කේතයක් එක් නොකරයි, එබැවින් සියුම් සුසර කිරීමකට පුහුණු අතිරේකයද අවශ්‍ය වේ. පැරණි එක්-පේළි මෙහි ආනයන වේලාවේදී අසාර්ථක වේ.

   bash

   # policy dependencies plus the training stack
   pip install 'lerobot[pi,training]'
   
   # from a source checkout
   pip install -e ".[pi,training]"
   
   # driving an SO-100 afterwards needs the robot extras too
   pip install 'lerobot[core_scripts,feetech]'

2. 2
   සත්‍යාපනය කරන්න

   බ්‍රවුසරයකින් paligemma-3b-pt-224 බලපත්‍රය පිළිගන්න, ඉන්පසු පුහුණු කරන යන්ත්‍රයට පිවිසෙන්න.

   bash

   hf auth login

3. 3
   ප්‍රමාණාංක සංඛ්‍යාලේඛන එක් කරන්න

   Pi0.5 STATE සහ ACTION ප්‍රමාණාංක සමඟ සාමාන්‍යකරණය කරයි, එබැවින් meta/stats.json සඳහා q01 සහ q99 අවශ්‍ය වේ. පැරණි දත්ත කට්ටලවල ඇත්තේ min, max, mean, std පමණි.

   bash

   lerobot-edit-dataset \
       --repo_id your_dataset \
       --new_repo_id your_dataset \
       --operation.type recompute_stats \
       --operation.overwrite true

4. 4
   lerobot/pi05_base වෙතින් සියුම් සුසර කරන්න

   ඔබේ කාඩ්පතට ඔරොත්තු දෙන පරිදි කණ්ඩායම් ප්‍රමාණය සකසන්න; ලේඛනවල LIBERO හි 80 GB දී 64 භාවිතා කරයි. bfloat16 පැහැදිලිවම ලබා දෙන්න, වින්‍යාසයේ පෙරනිමිය float32 වේ.

   bash

   lerobot-train \
       --dataset.repo_id=${HF_USER}/my_so100_dataset \
       --policy.type=pi05 \
       --policy.pretrained_path=lerobot/pi05_base \
       --policy.gradient_checkpointing=true \
       --policy.dtype=bfloat16 \
       --policy.device=cuda \
       --policy.push_to_hub=false \
       --output_dir=./outputs/pi05_so100 \
       --job_name=pi05_so100 \
       --batch_size=4 \
       --num_workers=8 \
       --steps=30000 \
       --save_freq=5000 \
       --seed=1000

5. 5
   එය අත මත ධාවනය කරන්න

   0.6.x හි මෙය lerobot-rollout වේ: lerobot-record ප්‍රතිපත්තියක් ප්‍රතික්ෂේප කරන අතර eval_ දත්ත කට්ටල නම් ප්‍රතික්ෂේප කරයි. Base අත ධාවනය කරයි, sentry rollout එක වාර්තා කරයි.

   bash

   lerobot-rollout \
       --strategy.type=base \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
       --task="Put lego brick into the transparent box" \
       --duration=60
   
   # same run, recorded into an eval_ dataset
   lerobot-rollout \
       --strategy.type=sentry \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --dataset.repo_id=${HF_USER}/eval_so100 \
       --dataset.single_task="Put lego brick into the transparent box" \
       --duration=600

පෙරනිමි කට්ටල තුනක් සහ පුහුණුකරු වෙත ළඟා වන්නේ කුමන ඒවාද

openpi's TrainConfig යනු මූලාශ්‍රයයි, LeRobot's PI05Config යනු ඔබ කිසිවක් නොකියන විට lerobot-train භාවිතා කරන දෙයයි, සහ මෙහි ඇති පෝරමය තුන්වන කට්ටලයක් යවයි. පුදුමය නම් ඉගෙනුම් අනුපාතයයි: ඉහළ ප්‍රවාහයේ පෙරනිමි අගයන් දෙකම 2.5e-5 දක්වා ඉහළ යන අතර, openpi's pi05_libero config සහ මෙම වේදිකාව එය 5e-5 දක්වා වැඩි කරයි.

පෝට් එක විශ්වාසදායකද? LeRobot කණ්ඩායම LIBERO මූලික ආකෘතිය තවත් 6k පියවර සඳහා සියුම් ලෙස සකස් කර, openpi හි යොමු අංක සමඟ සූට් හතරකදී සංසන්දනය කළේය: 97.5% සාමාන්‍යය 96.85 ට එරෙහිව, Libero 10 හි ඉදිරියෙන්, Spatial හි පසුපසින්. මෙම මාර්ගය මෙවලම් තේරීමක් මිස ගුණාත්මක තේරීමක් නොවේ.

485 ms යථාර්ථය, සහ එය භාවිතයට ගත නොහැකි වන තැන

මෙය ඔබේ ව්‍යාපෘතිය තීරණය කරයි, එබැවින් එය පිරිවැය වගුවට පෙර පැමිණේ. Pi0.5 සඳහා මෙහි මනින ලද එක් ක්‍රියාකාරී පියවරකට 485 ms වේ. අනෙක් හතරට සාපේක්ෂව:

උඩුගං ප්‍රවාහයට පිළිතුරක් ඇති අතර, එයින් අඩක් ඔබට ස්ථාපනය කළ හැකි නිකුතුවේ දැනටමත් ඇත. Real-Time Chunking මගින් ඊළඟ කොටස ජනනය කරන්නේ අත තවමත් වත්මන් කොටස ක්‍රියාත්මක කරන අතරතුර වන අතර, පසුව නව කොටසේ අතිච්ඡාදනය වන පියවර දැනටමත් ක්‍රියාත්මක කර ඇති කොටසට සමීපව තබා ගැනීමට මඟ පෙන්වයි, එවිට අත සන්ධියේදී නතර වීමක් හෝ ගැස්සීමක් සිදු නොවේ. Pi0, Pi0.5 සහ SmolVLA සඳහා 0.4.2 වෙනස්කම් ලැයිස්තුවේ අනුමාන-කාල ආකෘතිය නිකුත් කර ඇති අතර එය නැවත පුහුණු කිරීමක් නොව, rollout flag එකකි:

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/my_policy \
    --inference.type=rtc \
    --inference.rtc.execution_horizon=10 \
    --inference.rtc.max_guidance_weight=10.0 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
    --task="Put lego brick into the transparent box" \
    --duration=60

එය ආකෘතිය වේගවත් නොකරයි. එය පරතරය සඟවයි: මිලි තත්පර 485 තවමත් වැය වේ, නමුත් තීරණාත්මක මාර්ගයෙන් බැහැරව, එබැවින් කොටස් අතර පෝලිම හිස් නොවේ. arXiv 2512.05964 වෙතින් පුහුණු-කාල ප්‍රභේදය තවදුරටත් ඉදිරියට යයි: ආකෘතිය පිරිසිදු ක්‍රියාකාරී උපසර්ගයක් මත කොන්දේසිගත කිරීමට ඉගෙන ගනී, එබැවින් අනුමානයේදී අතිච්ඡාදනය මඟ පෙන්වීම වෙනුවට එක්-ක්‍රියාකාරී ප්‍රවාහ කාල පියවර සමඟ දැඩි ලෙස පින්තාරු කර ඇති අතර, මඟ පෙන්වීමේ පසුපස ගමන් මාර්ගය අතුරුදහන් වේ. පුහුණු කිරීමේදී එය එක් උදාහරණයකට උපසර්ග දිගක් නියැදි කරන අතර ඉතිරි පසුසර්ගය මත ප්‍රවාහ අලාභය ගනී. එම flag එක 0.6.1 හි නොව, ප්‍රධාන වශයෙන් පමණක් පවතී, තවද ඔබ පුහුණු කරන ප්‍රමාදය chunk_size ට වඩා අඩු විය යුතුය.

Pi0.5 චෙක්පොයින්ට් එකක් ලබා ගැනීමට ක්‍රම දෙකක්

lerobot-train \
    --dataset.repo_id=${HF_USER}/my_so100_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.rtc_training_max_delay=10 \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --batch_size=4 --steps=30000 --seed=1000

එය ක්‍රියා නොකරන විට

• දත්ත කට්ටලය ප්‍රතික්ෂේප කරන ලදී: v3 අවශ්‍යයි
• පුහුණු කිරීමේදී මතකය අවසන් වීම
• අලාභය අඩු වුවත් ප්‍රතිපත්තිය කිසිවක් නොකරයි
• චලනය මැද ප්‍රතිපත්තිය අක්‍රිය වීම
• ප්‍රතිපත්තිය ක්‍රියා කරන්නේ එක් සැකසුමක පමණි
• පුහුණු කිරීමේ කාර්යය පෝලිමේ සිරවීම

එක් ධාවනයකට වැය වන මුදල

Pi0.5 මිල අධික ස්ථරයේ පවතින්නේ එයට 80 GB කාඩ්පතක් අවශ්‍ය වන නිසාත්, ස්ථාන මිල ගණන් වෙනස් වන නිසාත්, එම නිසා අගය මිලකට වඩා පරාසයකි. බොහෝ SO-100 කාර්යයන් සඳහා, මුලින්ම 24 GB ස්ථරයේ SmolVLA හෝ ACT පුහුණු කරන්න, කාර්යය ඉගෙන ගත හැකි දැයි තහවුරු කර, පසුව ඒ සඳහා A100 පැය ගණනක් වැය කරන්න. ඔබේ පළමු ප්‍රතිපත්තිය පුහුණු කරන්න එම ලාභදායී චක්‍රය විස්තර කරන අතර, මිලකරණය වත්මන් ස්ථර දක්වයි.

සන්ධ්‍යාවක් කැප කිරීමට පෙර: GR00T N1.7 Pi0.5 ට එරෙහිව සහ Pi0.5 SmolVLA ට එරෙහිව එකම සංඛ්‍යා එකින් එක ඉදිරිපත් කරයි. අරීනා 332 මිණුම් සලකුණු ප්‍රතිඵල සහිත VLA මාදිලි 85ක් දරයි, ඒ සෑම එකක්ම එහි මූලාශ්‍රයට සම්බන්ධ කර ඇත, සහ පවුල පිළිබඳ පසුබිම අපගේ VLA දළ විශ්ලේෂණය.