ขอแนะนำ LiteRT: รันไทม์ประสิทธิภาพสูงของ Google สำหรับ AI ในอุปกรณ์ หรือที่รู้จักกันในชื่อ TensorFlow Lite

หน้านี้ได้รับการแปลโดย Cloud Translation API

คู่มือการสรุป LLM สำหรับเว็บ

LLM Inference API ช่วยให้คุณเรียกใช้โมเดลภาษาขนาดใหญ่ (LLM) ได้อย่างสมบูรณ์ใน สำหรับเว็บแอปพลิเคชัน ซึ่งสามารถใช้เพื่อทำงาน เช่น การสร้างข้อความ การดึงข้อมูลในรูปแบบภาษาธรรมชาติ และสรุปเอกสาร งานนี้มอบการสนับสนุนในตัวสำหรับ โมเดลภาษาขนาดใหญ่สำหรับการแปลงข้อความเป็นข้อความ เพื่อให้คุณใช้เวอร์ชันล่าสุดในอุปกรณ์ได้ โมเดล Generative AI ลงในเว็บแอป

คุณสามารถดูการทำงานนี้ได้ด้วย MediaPipe Studio การสาธิต สำหรับข้อมูลเพิ่มเติมเกี่ยวกับความสามารถ โมเดล และตัวเลือกการกำหนดค่า ของงานนี้ โปรดดูภาพรวม

ตัวอย่างโค้ด

ตัวอย่างแอปพลิเคชันสำหรับ LLM Inference API มีการปรับใช้พื้นฐาน งานนี้ในรูปแบบ JavaScript เพื่อเป็นข้อมูลอ้างอิง คุณใช้แอปตัวอย่างนี้เพื่อรับ เริ่มสร้างแอปสร้างข้อความของคุณเอง

คุณเข้าถึงแอปตัวอย่างใน LLM Inference API ได้ GitHub

ตั้งค่า

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

ความเข้ากันได้กับเบราว์เซอร์

LLM Inference API ต้องใช้เว็บเบราว์เซอร์ที่เข้ากันได้กับ WebGPU แบบเต็ม โปรดดูรายการเบราว์เซอร์ที่เข้ากันได้ในหัวข้อเบราว์เซอร์ GPU ความเข้ากันได้

แพ็กเกจ JavaScript

โค้ด LLM Inference API พร้อมใช้งานผ่าน @mediapipe/tasks-genai ใหม่ คุณค้นหาและดาวน์โหลดไลบรารีเหล่านี้ได้จากลิงก์ที่ให้ไว้ใน คู่มือการตั้งค่าแพลตฟอร์ม

ติดตั้งแพ็กเกจที่จำเป็นสำหรับการทดลองใช้ในเครื่อง

npm install @mediapipe/tasks-genai

หากต้องการทำให้เซิร์ฟเวอร์ใช้งานได้ ให้ใช้บริการเครือข่ายนำส่งข้อมูล (CDN) เช่น jsDelivr เพื่อเพิ่มโค้ดลงในหน้า HTML โดยตรง ให้ทำดังนี้

<head>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
    crossorigin="anonymous"></script>
</head>

รุ่น

MediaPipe LLM Inference API ต้องการโมเดลที่ผ่านการฝึกอบรมซึ่งใช้งานร่วมกับ งาน สำหรับเว็บแอปพลิเคชัน โมเดลต้องใช้ร่วมกับ GPU ได้

ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลที่ผ่านการฝึกที่พร้อมใช้งานสำหรับ LLM Inference API ได้ที่งาน ภาพรวมส่วนโมเดล

ดาวน์โหลดโมเดล

ก่อนเริ่มต้นใช้งาน LLM Inference API ให้ดาวน์โหลดโมเดลที่รองรับและ เก็บไฟล์ในไดเรกทอรีโปรเจ็กต์ของคุณ:

Gemma: เป็นส่วนหนึ่งของตระกูลโมเดลแบบเปิดที่ทันสมัยและน้ำหนักเบาซึ่งสร้างจาก การค้นคว้าวิจัยและเทคโนโลยีเดียวกับที่ใช้ในการสร้าง โมเดล Gemini เหมาะสำหรับแอปหลากหลาย งานการสร้างข้อความ ซึ่งรวมถึงการตอบคำถาม การสรุป และ การให้เหตุผล ดาวน์โหลดตัวแปรรุ่น Gemma 2B หรือ Gemma 7B
Phi-2: พารามิเตอร์ 2.7 พันล้านรายการ โมเดล Transformer เหมาะสำหรับการตอบคำถาม แชท และโค้ด
Falcon-RW-1B: 1 พันล้าน โมเดลแบบตัวถอดรหัสทั่วไปสำหรับพารามิเตอร์ที่ได้รับการฝึกในโทเค็น 350B ของ RefinedWeb
StableLM-3B: 3 พันล้านพารามิเตอร์ โมเดลภาษาที่ใช้เฉพาะตัวถอดรหัส ที่ได้รับการฝึกล่วงหน้าบน 1 ล้านล้าน โทเค็นของชุดข้อมูลภาษาอังกฤษและโค้ดที่หลากหลาย

เราขอแนะนำให้ใช้ Gemma 2B หรือ Gemma 7B ซึ่งมีให้บริการใน Kaggle รุ่นและรุ่น ในรูปแบบที่เข้ากันได้กับ LLM Inference API อยู่แล้ว หากคุณใช้ LLM อีกรายการ คุณจะต้องแปลงโมเดลเป็น รูปแบบที่ใช้ได้กับ MediaPipe ดูข้อมูลเพิ่มเติมเกี่ยวกับ Gemma ได้ที่ เว็บไซต์ Gemma ดูข้อมูลเพิ่มเติมเกี่ยวกับ โมเดลอื่นๆ ที่พร้อมใช้งาน โปรดดูภาพรวมงานส่วนโมเดล

แปลงโมเดลเป็นรูปแบบ MediaPipe

Conversion ของรูปแบบการระบุแหล่งที่มา

หากคุณใช้ LLM ภายนอก (Phi-2, Falcon หรือ StableLM) หรือที่ไม่ใช่ Kaggle ของ Gemma ให้ใช้สคริปต์ Conversion ของเราเพื่อจัดรูปแบบรูปแบบเป็น ทำงานร่วมกับ MediaPipe ได้

กระบวนการแปลงโมเดลต้องการแพ็กเกจ MediaPipe PyPI Conversion สคริปต์พร้อมใช้งานในแพ็กเกจ MediaPipe ทั้งหมดหลังจากวันที่ 0.10.11

ติดตั้งและนำเข้าทรัพยากร Dependency ด้วยตัวอย่างต่อไปนี้

$ python3 -m pip install mediapipe

ใช้ไลบรารี genai.converter เพื่อแปลงโมเดล

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

หากต้องการแปลงโมเดล LoRA ค่า ConversionConfig ควรระบุโมเดลฐาน รวมถึงตัวเลือก LoRA เพิ่มเติม โปรดสังเกตว่าเนื่องจากเฉพาะ API รองรับการอนุมาน LoRA ด้วย GPU ต้องตั้งค่าแบ็กเอนด์เป็น 'gpu'

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

ตัวแปลงจะแสดงไฟล์ TFLite Flatbuffer 2 ไฟล์ โดยไฟล์หนึ่งสำหรับโมเดลฐาน และอีกอย่างสำหรับโมเดล LoRA

พารามิเตอร์	คำอธิบาย	ค่าที่ยอมรับ
`input_ckpt`	เส้นทางไปยังไฟล์ `model.safetensors` หรือ `pytorch.bin` โปรดทราบว่าบางครั้งรูปแบบ Safetensor ของโมเดลจะถูกชาร์ตออกเป็นหลายไฟล์ เช่น `model-00001-of-00003.safetensors`, `model-00001-of-00003.safetensors` คุณระบุรูปแบบไฟล์ได้ เช่น `model*.safetensors`	เส้นทาง
`ckpt_format`	รูปแบบไฟล์โมเดล	{"safetensors", "pytorch"}
`model_type`	LLM กำลังแปลง	{"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
`backend`	ตัวประมวลผล (การมอบสิทธิ์) ที่ใช้ในการเรียกใช้โมเดล	{"cpu", "gpu"}
`output_dir`	เส้นทางไปยังไดเรกทอรีเอาต์พุตที่โฮสต์ไฟล์น้ำหนักต่อเลเยอร์	เส้นทาง
`output_tflite_file`	เส้นทางไปยังไฟล์เอาต์พุต ตัวอย่างเช่น "model_cpu.bin" หรือ "model_gpu.bin" ไฟล์นี้ใช้ร่วมกันได้กับ LLM Inference API เท่านั้น และใช้เป็นไฟล์ "tflite" ทั่วไปไม่ได้	เส้นทาง
`vocab_model_file`	เส้นทางไปยังไดเรกทอรีที่จัดเก็บ `tokenizer.json` และ `tokenizer_config.json` ไฟล์ สำหรับ Gemma ให้ชี้ไปที่ไฟล์ `tokenizer.model` ไฟล์เดียว	เส้นทาง
`lora_ckpt`	เส้นทางไปยังไฟล์ LoRA ckpt ของไฟล์ Safetensor ที่เก็บน้ำหนักของอะแดปเตอร์ LoRA	เส้นทาง
`lora_rank`	จำนวนเต็มที่แทนอันดับของ LoRA ckpt ต้องใช้เพื่อแปลงน้ำหนักลอรา หากไม่ระบุ ตัวแปลงจะถือว่าไม่มีน้ำหนัก LoRA หมายเหตุ: เฉพาะแบ็กเอนด์ GPU เท่านั้นที่รองรับ LoRA	จำนวนเต็ม
`lora_output_tflite_file`	ชื่อไฟล์ tflite สำหรับเอาต์พุตสำหรับน้ำหนักของ LoRA	เส้นทาง

การแปลงโมเดล AI Edge

หากคุณใช้ LLM ที่แมปกับโมเดล TFLite ผ่าน AI Edge ให้ใช้ กำลังจัดกลุ่มสคริปต์เพื่อสร้าง Task Bundle กระบวนการรวมกลุ่มจะประกอบไปด้วย โมเดลที่แมปพร้อมกับข้อมูลเมตาเพิ่มเติม (เช่น ต้องมีพารามิเตอร์ Tokenizer) เพื่อเรียกใช้การอนุมานจากต้นทางถึงปลายทาง

กระบวนการรวมโมเดลต้องมีแพ็กเกจ MediaPipe PyPI Conversion สคริปต์พร้อมใช้งานในแพ็กเกจ MediaPipe ทั้งหมดหลังจากวันที่ 0.10.14

ติดตั้งและนำเข้าทรัพยากร Dependency ด้วยตัวอย่างต่อไปนี้

$ python3 -m pip install mediapipe

ใช้ไลบรารี genai.bundler เพื่อรวมโมเดล:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

พารามิเตอร์	คำอธิบาย	ค่าที่ยอมรับ
`tflite_model`	เส้นทางไปยังโมเดล TFLite ที่ส่งออกของ AI Edge	เส้นทาง
`tokenizer_model`	เส้นทางไปยังโมเดลเครื่องมือแปลงข้อมูลเป็นโทเค็นของ SentencePiece	เส้นทาง
`start_token`	โทเค็นเริ่มต้นที่เจาะจงโมเดล โทเค็นเริ่มต้นต้องอยู่ในไฟล์ โมเดลโทเคนไลเซอร์ที่ให้ไว้	STRING
`stop_tokens`	สร้างโทเค็นหยุดเฉพาะรุ่น โทเค็นหยุดต้องมีอยู่ใน โมเดลโทเคนไลเซอร์ที่ให้ไว้	รายการ[สตริง]
`output_filename`	ชื่อของไฟล์กลุ่มงานเอาต์พุต	เส้นทาง

เพิ่มโมเดลในไดเรกทอรีโปรเจ็กต์

จัดเก็บโมเดลในไดเรกทอรีโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้

<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin

ระบุเส้นทางของโมเดลด้วยออบเจ็กต์ baseOptions modelAssetPath พารามิเตอร์:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}

สร้างงาน

ใช้ฟังก์ชัน createFrom...() ของ LLM Inference API เพื่อเตรียมงานสำหรับ การอนุมานในการวิ่ง คุณสามารถใช้ฟังก์ชัน createFromModelPath() กับ เส้นทางแบบสัมพัทธ์หรือสัมบูรณ์ไปยังไฟล์โมเดลที่ฝึก ตัวอย่างโค้ดใช้ createFromOptions() สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ ตัวเลือกการกำหนดค่า โปรดดูตัวเลือกการกำหนดค่า

โค้ดต่อไปนี้แสดงวิธีสร้างและกำหนดค่างานนี้

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
    baseOptions: {
        modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

ตัวเลือกการกำหนดค่า

งานนี้มีตัวเลือกการกำหนดค่าต่อไปนี้สำหรับแอปบนเว็บและ JavaScript

ชื่อตัวเลือก	คำอธิบาย	ช่วงค่า	ค่าเริ่มต้น
`modelPath`	เส้นทางไปยังที่เก็บโมเดลภายในไดเรกทอรีโปรเจ็กต์	เส้นทาง	ไม่มี
`maxTokens`	จำนวนโทเค็นสูงสุด (โทเค็นอินพุต + โทเค็นเอาต์พุต) ที่โมเดลจัดการได้	จำนวนเต็ม	512
`topK`	จำนวนโทเค็นที่โมเดลจะพิจารณาในแต่ละขั้นตอนของการสร้าง จำกัดการคาดการณ์ให้กับโทเค็นที่น่าจะเป็นมากที่สุด K สูงสุด	จำนวนเต็ม	40
`temperature`	ปริมาณการสุ่มที่เกิดขึ้นระหว่างการสร้าง สูงกว่า อุณหภูมิช่วยเพิ่มความสร้างสรรค์ ในข้อความที่สร้างขึ้น ขณะที่ อุณหภูมิที่ต่ำลงทำให้รุ่นที่คาดการณ์ได้มากขึ้น	ทศนิยม	0.8
`randomSeed`	Seed แบบสุ่มที่ใช้ระหว่างการสร้างข้อความ	จำนวนเต็ม	0
`loraRanks`	อันดับ LoRA ที่โมเดล LoRA จะใช้ในระหว่างรันไทม์ หมายเหตุ: วิธีนี้ใช้ได้เฉพาะกับรุ่น GPU	อาร์เรย์จำนวนเต็ม	ไม่มี

เตรียมข้อมูล

LLM Inference API รับข้อมูลข้อความ (string) งานจะจัดการอินพุตข้อมูล การประมวลผลล่วงหน้า ซึ่งรวมถึงการแปลงเป็นโทเค็นและการประมวลผลล่วงหน้า Tensor

การประมวลผลล่วงหน้าทั้งหมดจะจัดการภายในฟังก์ชัน generateResponse() มี ไม่จำเป็นต้องประมวลผลข้อความที่ป้อนไว้ล่วงหน้าเพิ่มเติม

const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";

เรียกใช้งาน

LLM Inference API ใช้ฟังก์ชัน generateResponse() เพื่อทริกเกอร์การอนุมาน สำหรับการจัดประเภทข้อความ จะหมายถึงการแสดงหมวดหมู่ที่เป็นไปได้สำหรับ ข้อความที่ป้อน

โค้ดต่อไปนี้แสดงวิธีดำเนินการประมวลผลกับงาน โมเดล

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

หากต้องการสตรีมคำตอบ ให้ใช้ขั้นตอนต่อไปนี้

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

จัดการและแสดงผลลัพธ์

LLM Inference API จะแสดงผลสตริง ซึ่งมีข้อความตอบกลับที่สร้างขึ้น

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

การปรับแต่งโมเดล LoRA

กำหนดค่า Mediapipe LLM Inference API ให้รองรับการปรับอันดับต่ำ (LoRA) ได้ สำหรับโมเดลภาษาขนาดใหญ่ นักพัฒนาซอฟต์แวร์สามารถใช้ประโยชน์จากโมเดล LoRA ที่ปรับแต่งแล้ว ปรับแต่งลักษณะการทำงานของ LLM ผ่านกระบวนการฝึกอบรมที่คุ้มค่า

การรองรับ LoRA ของ LLM Inference API ใช้งานได้กับโมเดล Gemma-2B และ Phi-2 สำหรับ แบ็กเอนด์ของ GPU ที่มีน้ำหนัก LoRA ที่ใช้กับเลเยอร์ความสนใจเท่านั้น ช่วงเวลานี้ การใช้งานเริ่มต้นทำหน้าที่เป็น API ทดลองสำหรับการพัฒนาในอนาคต โดยมีแผนที่จะรองรับโมเดลเพิ่มเติมและเลเยอร์ประเภทต่างๆ ในอนาคต อัปเดต

เตรียมโมเดล LoRA

ทำตามวิธีการใน HuggingFace เพื่อฝึกโมเดล LoRA ที่ปรับแต่งโดยละเอียดในชุดข้อมูลของคุณเองด้วยประเภทโมเดลที่รองรับ ได้แก่ Gemma-2B หรือ Phi-2 ทั้งรุ่น Gemma-2B และ Phi-2 มีให้บริการใน HuggingFace ในรูปแบบ Safetensors เนื่องจาก LLM Inference API รองรับเฉพาะ LoRA บนเลเยอร์ความสนใจ ให้ระบุเลเยอร์ความสนใจขณะสร้าง LoraConfig เท่านั้นดังนี้

# For Gemma-2B
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

มีโมเดล LoRA ที่ปรับแต่งอย่างละเอียดและเข้าถึงได้แบบสาธารณะซึ่งเหมาะกับ LLM Inference API ซึ่งพร้อมใช้งานใน HuggingFace เช่น monsterapi/gemma-2b-lora-maths-orca-200k สำหรับ Gemma-2B และ lole25/phi-2-sft-ultrachat-lora สำหรับ Phi-2

หลังจากฝึกในชุดข้อมูลที่เตรียมไว้และบันทึกโมเดล คุณได้รับไฟล์ adapter_model.safetensors ที่มีน้ำหนักโมเดล LoRA ที่ปรับแต่งอย่างละเอียด ไฟล์ Safetensor คือจุดตรวจ LoRA ที่ใช้ในการแปลงโมเดล

ในขั้นตอนถัดไป คุณต้องแปลงน้ำหนักโมเดลเป็น Flatbuffer ของ TensorFlow Lite โดยใช้แพ็กเกจ MediaPipe Python ConversionConfig ควรระบุตัวเลือกรุ่นพื้นฐานรวมถึงตัวเลือก LoRA เพิ่มเติม โปรดสังเกตว่าเนื่องจาก API รองรับการอนุมาน LoRA กับ GPU เท่านั้น จึงต้องตั้งค่าแบ็กเอนด์เป็น 'gpu'

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

การอนุมานโมเดล LoRA

LLM Inference API บนเว็บ, Android และ iOS ได้รับการอัปเดตให้รองรับการอนุมานโมเดล LoRA เว็บรองรับ LoRA แบบไดนามิก ซึ่งเปลี่ยน LoRA รุ่นต่างๆ ในระหว่างรันไทม์ได้ Android และ iOS รองรับ LoRA แบบคงที่ ซึ่งใช้น้ำหนัก LoRA เดียวกันตลอดอายุของงาน

เว็บรองรับ LoRA แบบไดนามิกระหว่างรันไทม์ กล่าวคือ ผู้ใช้จะประกาศว่าจะใช้อันดับ LoRA ในระหว่างการเริ่มต้นและสลับโมเดล LoRA แบบต่างๆ ระหว่างรันไทม์ได้

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
    // options for the base model
    ...
    // LoRA ranks to be used by the LoRA models during runtime
    loraRanks: [4, 8, 16]
});

ในระหว่างรันไทม์ ให้โหลดโมเดล LoRA ที่จะใช้หลังจากเริ่มโมเดลฐานแล้ว นอกจากนี้ ให้ทริกเกอร์โมเดล LoRA โดยการส่งการอ้างอิงโมเดล LoRA ในขณะที่สร้างการตอบสนอง LLM

// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);

// Specify LoRA model to be used during inference
llmInference.generateResponse(
  inputPrompt,
  loraModelRank4,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});