10 อันดับโมเดล Vision Language แห่งปี 2026

Vision Language Models (VLMs) กำลังพลิกโฉมอุตสาหกรรมอย่างรวดเร็วด้วยการทำให้ระบบ AI เข้าใจและให้เหตุผลได้ทั้งภาพและข้อความ ต่างจากโมเดลคอมพิวเตอร์วิทัศน์แบบดั้งเดิม VLM สมัยใหม่สามารถตีความภาพที่ซับซ้อน ตอบคำถามเชิงลึกเกี่ยวกับเนื้อหาภาพ และแม้แต่ประมวลผลวิดีโอและเอกสารที่มีข้อความฝังอยู่ได้ 

คุณสมบัตินี้ทำให้มีคุณค่าอย่างยิ่งในงานวินิจฉัยทางการแพทย์ การควบคุมคุณภาพอัตโนมัติ และงานอ่อนไหวที่ความแม่นยำสำคัญกว่าความเร็ว

ในบล็อกนี้จะพารีวิวโมเดลวิชัน–แลนเกจชั้นนำของปี 2026 ทั้งแบบโอเพนซอร์สและเชิงพาณิชย์ โดยจะชี้จุดเด่นของแต่ละตัว พร้อมสรุปสมรรถนะและผลเบนช์มาร์ก สำหรับนักพัฒนาและนักวิจัย ยังมีโค้ดตัวอย่างให้ลองใช้งานโมเดลเหล่านี้ได้อย่างรวดเร็ว

หากต้องการเรียนรู้พื้นฐานของโมเดลเหล่านี้เพิ่มเติม อย่าพลาด Image Processing in Python skill track

1. Gemini 2.5 Pro

Gemini 2.5 Pro คือโมเดล AI ขั้นสูงสุดของ Google นำตารางจัดอันดับ LMArena และ WebDevArena ทั้งงานด้านวิชันและโค้ดดิ้ง ออกแบบมาสำหรับการให้เหตุผลและความเข้าใจเชิงซับซ้อนครอบคลุมข้อความ ภาพ เสียง และวิดีโอ

ด้านความสามารถวิชัน–แลนเกจ จัดเป็นหนึ่งในโมเดลชั้นนำบน Open LLM leaderboard Gemini 2.5 Pro ตีความภาพและวิดีโอได้ สร้างคำอธิบายละเอียดพร้อมบริบท และตอบคำถามที่เกี่ยวกับเนื้อหาภาพได้อย่างแม่นยำ

ที่มา: ‎Google Gemini

เข้าถึง Gemini 2.5 Pro ได้ฟรีผ่านเว็บแอป Gemini ที่ gemini.google.com/app หรือใช้ Google AI Studio

สำหรับนักพัฒนา Gemini 2.5 Pro ยังพร้อมใช้งานผ่าน Gemini API, Vertex AI และ Python SDK ทางการ ช่วยผนวกความสามารถวิชัน–แลนเกจเข้ากับแอปหรือเวิร์กโฟลว์ได้ง่าย

ตัวอย่างการใช้งาน:

from google.genai import types

with open('path/to/image.jpg', 'rb') as f:
      image_bytes = f.read()

  response = client.models.generate_content(
    model='gemini-2.5-pro',
    contents=[
      types.Part.from_bytes(
        data=image_bytes,
        mime_type='image/jpeg',
      ),
      'Explain the image.'
    ]
  )
print(response.text)

2. InternVL3-78B

InternVL3 คือชุดโมเดลภาษาขนาดใหญ่เชิงมัลติโหมด (MLLMs) ขั้นก้าวหน้าที่ทำผลงานเหนือกว่า InternVL 2.5 รุ่นก่อน โดดเด่นทั้งการรับรู้และให้เหตุผลแบบหลายโมดาลิตี้ พร้อมเสริมความสามารถอย่างการใช้เครื่องมือ เอเจนต์สำหรับ GUI การวิเคราะห์ภาพอุตสาหกรรม และการรับรู้ภาพ 3 มิติ

โมเดล InternVL3-78B ใช้ InternViT-6B-448px-V2_5 เป็นองค์ประกอบวิชัน และ Qwen2.5-72B เป็นองค์ประกอบภาษา รวมทั้งสิ้น 78.41 พารามิเตอร์พันล้าน ทำคะแนน 72.2 บนเบนช์มาร์ก MMMU สร้างสถิติใหม่สำหรับ MLLM แบบโอเพนซอร์ส โดยมีสมรรถนะทัดเทียมโมเดลเชิงพาณิชย์ชั้นนำ

ที่มา: OpenGVLab/InternVL3-78B · Hugging Face

ตัวอย่างการใช้งาน:

# pip install lmdeploy>=0.7.3
from lmdeploy import pipeline, TurbomindEngineConfig, ChatTemplateConfig
from lmdeploy.vl import load_image

model = 'OpenGVLab/InternVL3-78B'
image = load_image('https://raw.githubusercontent.com/open-mmlab/mmdeploy/main/tests/data/tiger.jpeg')
pipe = pipeline(model, backend_config=TurbomindEngineConfig(session_len=16384, tp=4), chat_template_config=ChatTemplateConfig(model_name='internvl2_5'))
response = pipe(('Explain the image.', image))
print(response.text)

3. Ovis2-34B

Ovis2 คือชุดโมเดลภาษาขนาดใหญ่เชิงมัลติโหมด (MLLMs) ที่พัฒนาโดย AIDC-AI ออกแบบมาเพื่อจัดแนวเวกเตอร์ฝังตัวของภาพและข้อความได้อย่างมีประสิทธิภาพ โดยเฉพาะรุ่น Ovis2-34B ใช้ตัวเข้ารหัสวิชัน aimv2-1B-patch14-448 และใช้ Qwen2.5-32B-Instruct เป็นโมเดลภาษา รวม 34 พันล้านพารามิเตอร์ รองรับความยาวบริบทสูงสุด 32,768 โทเค็น และใช้ความแม่นยำ bfloat16 เพื่อประมวลผลอย่างมีประสิทธิภาพ

Ovis2-34B ทำผลงานได้แข็งแกร่งบนเบนช์มาร์กหลากหลายรายการ โดยทำได้ดังนี้:

• MMBench-V1.1: 86.6% 
• MMStar: 69.2% 
• MMMUval: 66.7% 
• MathVista: 76.1% 
• MMVet: 77.1% 
• VideoMME: 75.6% พร้อมคำบรรยาย 

ที่มา: AIDC-AI/Ovis2-34B · Hugging Face

ตัวอย่างการใช้งาน:

import torch
from PIL import Image
from transformers import AutoModelForCausalLM

# load model
model = AutoModelForCausalLM.from_pretrained("AIDC-AI/Ovis2-34B",
                                             torch_dtype=torch.bfloat16,
                                             multimodal_max_length=32768,
                                             trust_remote_code=True).cuda()
text_tokenizer = model.get_text_tokenizer()
visual_tokenizer = model.get_visual_tokenizer()

# single-image input
image_path = '/data/images/example_1.jpg'
images = [Image.open(image_path)]
max_partition = 9
text = 'Describe the image.'
query = f'<image>\n{text}'



# format conversation
prompt, input_ids, pixel_values = model.preprocess_inputs(query, images, max_partition=max_partition)
attention_mask = torch.ne(input_ids, text_tokenizer.pad_token_id)
input_ids = input_ids.unsqueeze(0).to(device=model.device)
attention_mask = attention_mask.unsqueeze(0).to(device=model.device)
if pixel_values is not None:
    pixel_values = pixel_values.to(dtype=visual_tokenizer.dtype, device=visual_tokenizer.device)
pixel_values = [pixel_values]

# generate output
with torch.inference_mode():
    gen_kwargs = dict(
        max_new_tokens=1024,
        do_sample=False,
        top_p=None,
        top_k=None,
        temperature=None,
        repetition_penalty=None,
        eos_token_id=model.generation_config.eos_token_id,
        pad_token_id=text_tokenizer.pad_token_id,
        use_cache=True
    )
    output_ids = model.generate(input_ids, pixel_values=pixel_values, attention_mask=attention_mask, **gen_kwargs)[0]
    output = text_tokenizer.decode(output_ids, skip_special_tokens=True)
    print(f'Output:\n{output}')

4. Qwen2.5-VL-72B-Instruct

Qwen2.5-VL-72B-Instruct เป็นโมเดลภาษาขนาดใหญ่เชิงมัลติโหมด (MLLM) ในตระกูล Qwen ที่ออกแบบมาเพื่อเข้าใจและประมวลผลข้อมูลทั้งเชิงภาพและเชิงข้อความ โมเดล MLLM โอเพนซอร์สจำนวนมากพัฒนาต่อยอดจากมัน สะท้อนว่า Qwen มีบทบาทสำคัญต่อความก้าวหน้าในงานวิจัย AI

Qwen2.5-VL-72B-Instruct ทำผลงานแข็งแกร่งบนเบนช์มาร์กหลากหลาย ทั้งความสามารถด้านความเข้าใจภาพและวิดีโอ รวมถึงบทบาทแบบเอเจนต์ ทำคะแนน 70.2 บน MMMUval, 74.8 บน MathVista_MINI และ 70.8 บน MMStar 

ที่มา: Qwen/Qwen2.5-VL-72B-Instruct · Hugging Face

ตัวอย่างการใช้งาน:

# pip install qwen-vl-utils[decord]==0.0.8

from transformers import Qwen2_5_VLForConditionalGeneration, AutoTokenizer, AutoProcessor
from qwen_vl_utils import process_vision_info

# default: Load the model on the available device(s)
model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-VL-72B-Instruct", torch_dtype="auto", device_map="auto"
)
# default processer
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-72B-Instruct")




messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

# Preparation for inference
text = processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)
image_inputs, video_inputs = process_vision_info(messages)
inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
)
inputs = inputs.to("cuda")

# Inference: Generation of the output
generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_ids_trimmed = [
    out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
output_text = processor.batch_decode(
    generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

5. o3 รุ่นล่าสุด

o3 ของ OpenAI เป็นโมเดลให้เหตุผลรุ่นใหม่ที่ออกแบบมาเพื่อมอบความฉลาดสูงขึ้น ต้นทุนต่ำลง และใช้โทเค็นอย่างมีประสิทธิภาพยิ่งขึ้นในแอปพลิเคชัน ถือเป็นเจเนอเรชันใหม่ที่ให้ความสำคัญกับความสามารถด้านการให้เหตุผลขั้นสูง 

โมเดลนี้ยกระดับมาตรฐานงานคณิตศาสตร์ วิทยาศาสตร์ โค้ดดิ้ง และการให้เหตุผลเชิงภาพ บนเบนช์มาร์กด้านวิชันหลากหลายรายการ ทำผลงานดีกว่า o4-min และ o1 และทัดเทียม o3 Pro

ที่มา: Introducing OpenAI o3 and o4-mini | OpenAI

ตัวอย่างการใช้งาน:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="o3-2025-04-16",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "what's in this image?"},
            {
                "type": "input_image",
                "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
            },
        ],
    }],
)

print(response.output_text)

6. GPT 4.1 (2025-04-14)

GPT-4.1 เป็นตระกูลโมเดลแบบไม่เน้นให้เหตุผล (non-reasoning) รุ่นใหม่ ประกอบด้วย GPT-4.1, GPT-4.1 Mini และ GPT-4.1 Nano ซึ่งทำผลงานเหนือกว่า GPT-4o และ GPT-4o Mini รุ่นก่อนบนเบนช์มาร์กต่าง ๆ

GPT-4.1 รักษาความสามารถด้านวิชันไว้ได้อย่างแข็งแกร่ง พร้อมพัฒนาการในการวิเคราะห์กราฟ แผนภาพ และคณิตศาสตร์เชิงภาพ เด่นในงานนับวัตถุ ตอบคำถามจากภาพ (VQA) และ OCR หลายรูปแบบ 

ที่มา: Introducing GPT-4.1 in the API | OpenAI

ตัวอย่างการใช้งาน:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-2025-04-14",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "what's in this image?"},
            {
                "type": "input_image",
                "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
            },
        ],
    }],
)

print(response.output_text)

7. Claude Sonnet 4

Anthropic เปิดตัวเจเนอเรชันถัดไปของโมเดล Claude ได้แก่ Claude 4 Opus และ Claude 4 Sonnet ซึ่งตั้งเป้ายกระดับมาตรฐานด้านโค้ดดิ้ง การให้เหตุผลขั้นสูง และความสามารถของ AI 

มาพร้อมความสามารถด้านวิชันที่ดีขึ้น ผู้ใช้สามารถทำความเข้าใจภาพแล้วให้โมเดลสร้างโค้ดหรือให้ข้อมูลตามภาพนั้น ๆ แม้โดยพื้นฐานจะเป็นโมเดลสำหรับโค้ดดิ้ง แต่ก็รองรับมัลติโหมด เข้าใจไฟล์ได้หลายรูปแบบ

จากตารางเปรียบเทียบด้านล่างจะเห็นว่า Claude 4 ทำผลงานเหนือกว่าท็อปโมเดลส่วนใหญ่ ยกเว้น GPT-3 ของ OpenAI โดยเฉพาะในการให้เหตุผลเชิงภาพและการตอบคำถามจากภาพ

ที่มา: Introducing Claude 4 \ Anthropic

ตัวอย่างการใช้งาน:

import anthropic

client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Describe this image."
                }
            ],
        }
    ],
)
print(message)

8. Kimi-VL-A3B-Thinking-2506

Kimi-VL-A3B-Thinking-2506 เป็นโมเดลโอเพนซอร์สที่สะท้อนก้าวกระโดดสำคัญของ AI เชิงมัลติโหมด โดดเด่นบนเบนช์มาร์กการให้เหตุผลแบบมัลติโหมด ทำคะแนนความแม่นยำได้ 56.9 บน MathVision, 80.1 บน MathVista, 46.3 บน MMMU-Pro และ 64.0 บน MMMU พร้อมลด "ความยาวการคิด" โดยเฉลี่ยลง 20%

นอกจากด้านการให้เหตุผลแล้ว เวอร์ชัน 2506 ยังพัฒนาความสามารถการรับรู้และความเข้าใจภาพทั่วไปให้ดีขึ้น ทำผลงานได้ทัดเทียมหรือดีกว่าโมเดลแบบไม่คิด (non-thinking) บนเบนช์มาร์กอย่าง MMBench-EN-v1.1 (84.4), MMStar (70.4), RealWorldQA (70.0) และ MMVet (78.4)

ที่มา: MoonshotAI/Kimi-VL: Kimi-VL

ตัวอย่างการใช้งาน:

from transformers import AutoProcessor
from vllm import LLM, SamplingParams

model_path = "moonshotai/Kimi-VL-A3B-Thinking-2506"
llm = LLM(
    model_path,
    trust_remote_code=True,
    max_num_seqs=8,
    max_model_len=131072,
    limit_mm_per_prompt={"image": 256}
)

processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)

sampling_params = SamplingParams(max_tokens=32768, temperature=0.8)


import requests
from PIL import Image

def extract_thinking_and_summary(text: str, bot: str = "◁think▷", eot: str = "◁/think▷") -> str:
    if bot in text and eot not in text:
        return ""
    if eot in text:
        return text[text.index(bot) + len(bot):text.index(eot)].strip(), text[text.index(eot) + len(eot) :].strip()
    return "", text

OUTPUT_FORMAT = "--------Thinking--------\n{thinking}\n\n--------Summary--------\n{summary}"

url = "https://huggingface.co/spaces/moonshotai/Kimi-VL-A3B-Thinking/resolve/main/images/demo6.jpeg"
image = Image.open(requests.get(url,stream=True).raw)

messages = [
    {"role": "user", "content": [{"type": "image", "image": ""}, {"type": "text", "text": "What kind of cat is this? Answer with one word."}]}
]
text = processor.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt")

outputs = llm.generate([{"prompt": text, "multi_modal_data": {"image": image}}], sampling_params=sampling_params)
generated_text = outputs[0].outputs[0].text

thinking, summary = extract_thinking_and_summary(generated_text)
print(OUTPUT_FORMAT.format(thinking=thinking, summary=summary))

9. Gemma-3-27b-it

Gemma 3 เป็นตระกูลโมเดล AI เชิงมัลติโหมดจาก Google ที่ประมวลผลอินพุตเป็นข้อความและภาพเพื่อสร้างเอาต์พุตเป็นข้อความ มีหลายขนาด ได้แก่ 1B, 4B, 12B และ 27B เพื่อตอบโจทย์ฮาร์ดแวร์และสมรรถนะที่ต่างกัน

รุ่นที่ใหญ่สุด Gemma 3 27B ทำผลงานได้โดดเด่นในการประเมินความพึงพอใจของมนุษย์ ถึงขั้นเหนือกว่าโมเดลที่ใหญ่กว่าอย่าง Llama 3-405B และ DeepSeek-V3 

โมเดลเหล่านี้แสดงศักยภาพที่ดีบนเบนช์มาร์กหลากหลาย โดยเฉพาะงานมัลติโหมด ทำคะแนนเด่นบน COCOcap (116), DocVQA (85.6), MMMU (56.1) และ VQAv2 (72.9)

ที่มา: Open VLM Leaderboard

ตัวอย่างการใช้งาน:

# pip install accelerate

from transformers import AutoProcessor, Gemma3ForConditionalGeneration
from PIL import Image
import requests
import torch

model_id = "google/gemma-3-27b-it"

model = Gemma3ForConditionalGeneration.from_pretrained(
    model_id, device_map="auto"
).eval()

processor = AutoProcessor.from_pretrained(model_id)

messages = [
    {
        "role": "system",
        "content": [{"type": "text", "text": "You are a helpful assistant."}]
    },
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"},
            {"type": "text", "text": "Describe this image in detail."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt"
).to(model.device, dtype=torch.bfloat16)

input_len = inputs["input_ids"].shape[-1]

with torch.inference_mode():
    generation = model.generate(**inputs, max_new_tokens=100, do_sample=False)
    generation = generation[0][input_len:]

decoded = processor.decode(generation, skip_special_tokens=True)
print(decoded)

10. Llama-3.2-90B-Vision-Instruct

โมเดล Llama 3.2 90B Vision Instruct เป็นโมเดลภาษาขนาดใหญ่เชิงมัลติโหมดขั้นสูงจาก Meta ออกแบบมาสำหรับงานรู้จำภาพ การให้เหตุผลจากภาพ และการทำคำบรรยายภาพ 

Llama 3.2 90B Vision Instruct สร้างบนพื้นฐาน Llama 3.1 รุ่นข้อความล้วน และผนวกตัวปรับวิชันที่เทรนแยกต่างหาก ทำให้รับอินพุตได้ทั้งภาพและข้อความ และสร้างเอาต์พุตเป็นข้อความได้อย่างแม่นยำ

เทรนในสเกลมหาศาล ใช้เวลา GPU รวม 8.85 ล้านชั่วโมง แสดงสมรรถนะยอดเยี่ยมบน VQAv2 (73.6), Text VQA (73.5) และ DocVQA (70.7)

ที่มา: llama-models

ตัวอย่างการใช้งาน:

import requests
import torch
from PIL import Image
from transformers import MllamaForConditionalGeneration, AutoProcessor

model_id = "meta-llama/Llama-3.2-90B-Vision-Instruct"

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
processor = AutoProcessor.from_pretrained(model_id)

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "If I had to write a haiku for this one, it would be: "}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(
    image,
    input_text,
    add_special_tokens=False,
    return_tensors="pt",
).to(model.device)

output = model.generate(**inputs, max_new_tokens=30)
print(processor.decode(output[0]))

การให้เหตุผลเชิงภาพด้วยกราฟยังเป็นจุดแข็งของโมเดลใหม่ล่าสุดจาก Meta อย่าง Muse Spark ด้วย

ข้อคิดส่งท้าย

โมเดลวิชัน–แลนเกจกำลังเปลี่ยนวิธีที่ปฏิสัมพันธ์กับข้อมูลทั้งภาพและข้อความอย่างสิ้นเชิง มอบความแม่นยำและความยืดหยุ่นที่น่าทึ่งครอบคลุมอุตสาหกรรมหลากหลาย ผสานคอมพิวเตอร์วิทัศน์กับการประมวลผลภาษาธรรมชาติได้อย่างแนบเนียน เปิดทางสู่งานประยุกต์ใหม่ ๆ ตั้งแต่การตรวจจับวัตถุขั้นสูงไปจนถึงผู้ช่วยเชิงภาพที่ใช้งานง่าย

หากความเป็นส่วนตัวและความปลอดภัยคือสิ่งสำคัญ แนะนำให้สำรวจโมเดลวิชัน–แลนเกจแบบโอเพนซอร์ส การรันโมเดลเหล่านี้แบบโลคัลทำให้ควบคุมข้อมูลได้เต็มที่ เหมาะกับสภาพแวดล้อมที่อ่อนไหว อีกทั้งยังปรับแต่งได้สูง โดยมากสามารถไฟน์จูนด้วยตัวอย่างเพียงไม่กี่ร้อยตัวอย่างเพื่อให้ผลลัพธ์ยอดเยี่ยมตามโจทย์เฉพาะ

ในทางกลับกัน โมเดลเชิงพาณิชย์มอบการเข้าถึงความสามารถระดับแนวหน้าอย่างน่าเชื่อถือและคุ้มค่า มักมีความแม่นยำสูง และผนวกรวมเข้ากับเวิร์กโฟลว์ได้ด้วยโค้ดเพียงไม่กี่บรรทัด ทำให้ทีมที่ไม่เชี่ยวชาญ AI ลึกมากก็เริ่มใช้งานได้

หากต้องการเรียนรู้เกี่ยวกับโมเดลวิชัน–แลนเกจเพิ่มเติม ลองดูแหล่งข้อมูลเหล่านี้: 

• Image Processing in Python: การฝึกปฏิบัติเทคนิคการประมวลผลภาพที่จำเป็น เช่น การปรับแต่ง การวิเคราะห์ และการสกัดคุณลักษณะ
• Deep Learning for Images with PyTorch:  ลงมือทำกับโครงข่ายคอนโวลูชัน (CNNs), ทรานสเฟอร์เลิร์นนิง และการพัฒนาโมเดลวิชันเฉพาะทาง
• Natural Language Processing in Python: เส้นทางทักษะด้านการประมวลผลและวิเคราะห์ข้อมูลข้อความ ซึ่งสำคัญต่อแอปมัลติโหมดที่ผสาน NLP กับคอมพิวเตอร์วิทัศน์