# 08. HuggingFace Pipeline

## HuggingFace Pipeline

### HuggingFace Local Pipelines

class `HuggingFacePipeline` memungkinkan Anda menjalankan model Hugging Face secara lokal.

[Hugging Face Model Hub](https://www.google.com/url?q=https%3A%2F%2Fhuggingface.co%2Fmodels) menampung lebih dari 120.000 model, 20.000 set data, dan 50.000 aplikasi demo (Spaces) di platform online, yang semuanya bersifat open source dan tersedia untuk umum, sehingga memudahkan orang untuk berkolaborasi dan membangun ML bersama-sama.

Model-model ini dapat digunakan di LangChain dengan memanggilnya melalui pembungkus pipeline lokal ini, atau dengan memanggil titik akhir inferensi yang dihosting melalui kelas HuggingFaceHub. Untuk informasi lebih lanjut tentang pipa yang dihosting, lihat buku catatan [HuggingFaceHub](https://www.google.com/url?q=https%3A%2F%2Fwikidocs.net%2Fhuggingface_hub).

Untuk menggunakannya, Anda harus memiliki paket [Python transformer](https://www.google.com/url?q=https%3A%2F%2Fpypi.org%2Fproject%2Ftransformers%2F) yang diinstal dengan [PyTorch](https://www.google.com/url?q=https%3A%2F%2Fpytorch.org%2Fget-started%2Flocally%2F)

Anda juga dapat menginstal `xformer` untuk implementasi perhatian yang lebih hemat memori.

```python
%pip install --upgrade --quiet  transformers --quiet
```

Mengatur path untuk mengunduh model

```python
# path untuk mengunduh model HuggingFace/talkizer
import os

# atur untuk mengunduh ke jalur ./cache/
os.environ["TRANSFORMERS_CACHE"] = "./cache/"
os.environ["HF_HOME"] = "./cache/"
```

## Model loading

Model dapat dimuat dengan menentukan parameter model menggunakan metode `from_model_id`.

* Gunakan class `HuggingFacePipeline` untuk memuat model wajah berpelukan yang telah dilatih sebelumnya.
* Gunakan metode `from_model_id` untuk menentukan model `beomi/llama-2-en-7b`, dan atur aksi ke “text-generation”.
* Gunakan parameter `pipeline_kwargs` untuk membatasi jumlah maksimum token yang akan dihasilkan hingga 10.
* Model yang dimuat ditetapkan ke variabel `hf`, yang memungkinkan Anda untuk melakukan tugas pembuatan teks.

Model yang digunakan: [https://huggingface.co/beomi/llama-2-ko-7b](https://www.google.com/url?q=https%3A%2F%2Fhuggingface.co%2Fbeomi%2Fllama-2-ko-7b)

```python
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
```

```python
# Unduh model HuggingFace.
hf = HuggingFacePipeline.from_model_id(
    model_id=“beomi/llama-2-ko-7b”, # Tentukan ID model yang akan digunakan.
    task = “text-generation”, # Tentukan tugas yang akan dilakukan. Dalam hal ini, ini adalah pembuatan teks.
    # Tetapkan argumen tambahan yang akan diteruskan ke pipeline. Di sini kita membatasi jumlah maksimum token yang akan dihasilkan hingga 10.
    pipeline_kwargs = {“max_new_token”: 512},
)
```

Anda juga dapat melewatkan pipeline `transformer` yang sudah ada secara langsung untuk memuatnya.

Menerapkan model pembuatan teks menggunakan HuggingFacePipeline.

* Muat model `beomi/llama-2-en-7b` dan tokeniser menggunakan `AutoTokeniser` dan `AutoModelForCausalLM`.
* Buat `pipeline` “text-generation” menggunakan fungsi pipeline, dan siapkan model dan tokeniser. Batasi jumlah maksimum token yang dihasilkan hingga 10.
* Buat objek hf menggunakan kelas `HuggingFacePipeline`, dan berikan pipeline yang dihasilkan.

Anda dapat menggunakan objek `hf` yang dihasilkan ini untuk melakukan pembuatan teks untuk prompt yang diberikan.

```python
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

model_id = “beomi/llama-2-en-7b” # Tentukan ID model yang akan digunakan.
tokenizer = AutoTokenizer.from_pretrained(
    model_id
) # Memuat tokeniser untuk model yang ditentukan.
model = AutoModelForCausalLM.from_pretrained(model_id) # Memuat model yang ditentukan.
# Buat pipeline pembuatan teks, dan atur jumlah maksimum token baru yang akan dihasilkan menjadi 10.
pipe = pipeline(“text-generation”, model = model,
                tokenizer = tokenizer, max_new_token = 512)
# Buat objek HuggingFacePipeline dan berikan pipeline yang telah dibuat.
hf = HuggingFacePipeline(pipeline=pipe)
```

## Membuat Chain

Setelah model dimuat ke dalam memori, model tersebut dapat dikonfigurasikan dengan prompt untuk membentuk rantai.

* Gunakan class `PromptTemplate` untuk membuat template prompt yang mendefinisikan format pertanyaan dan jawaban.
* Pipeline objek `prompt` dan objek `hf` untuk membuat objek `chain`.
* Panggil metode `chain.invoke()` untuk membuat dan mencetak jawaban dari pertanyaan yang diberikan.

```python
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser

template = """Jawablah pertanyaan berikut dalam bahasa Indonesia.
#Pertanyaan:
{pertanyaan}

#Pertanyaan: {pertanyaan} #Jawaban: """ # Template untuk menentukan format pertanyaan dan jawaban
prompt = PromptTemplate.from_template(template) # membuat objek prompt menggunakan template

# membuat chain dengan menggabungkan prompt dan model bahasa
chain = prompt | hf | StrOutputParser()

question = “Apa ibu kota Indonesia?” # Mendefinisikan pertanyaan

print(
    chain.invoke({“pertanyaan”: pertanyaan})
) # Memanggil chain untuk menghasilkan dan mencetak jawaban dari pertanyaan
```

## Inferensi GPU

Ketika menjalankan pada GPU, Anda dapat menentukan parameter `device=n` untuk menempatkan model pada perangkat tertentu.

Nilai defaultnya adalah `-1`, yang melakukan inferensi pada CPU.

Jika Anda memiliki beberapa GPU atau model Anda terlalu besar untuk satu GPU, Anda dapat menentukan `device_map=“auto”`.

Dalam kasus ini, library [Accelerate](https://www.google.com/url?q=https%3A%2F%2Fhuggingface.co%2Fdocs%2Faccelerate%2Findex) diperlukan dan akan digunakan untuk secara otomatis menentukan cara memuat bobot model.

Perhatian: `device` dan `device_map` tidak boleh ditentukan secara bersamaan, karena hal ini dapat menyebabkan perilaku yang tidak diharapkan.

* Muat model `gpt2` menggunakan `HuggingFacePipeline`, atur parameter `device` ke 0 agar dapat berjalan pada GPU.
* Gunakan parameter `pipeline_kwargs` untuk membatasi jumlah maksimum token yang akan dihasilkan menjadi 10.
* Buat `gpu_chain` dengan pipelining `prompt` dan `gpu_llm`.
* Panggil metode `gpu_chain.invoke()` untuk menghasilkan dan menampilkan jawaban dari pertanyaan yang diberikan.

```python
gpu_llm = HuggingFacePipeline.from_model_id(
    model_id=“beomi/llama-2-en-7b”, # Tentukan ID model yang akan digunakan.
    task = “text-generation”, # Tetapkan tugas yang akan dilakukan. Dalam hal ini, ini adalah pembuatan teks.
    # Tentukan nomor perangkat GPU yang akan digunakan. Jika diatur ke “auto”, maka akan menggunakan library accelerate.
    device=0,
    # Tetapkan argumen tambahan yang akan diteruskan ke pipeline. Di sini kita membatasi jumlah maksimum token yang akan dihasilkan hingga 10.
    pipeline_kwargs = {“max_new_token”: 64},
)

gpu_chain = prompt | gpu_llm # Gabungkan prompt dan gpu_llm untuk membuat gpu_chain.

# Menggabungkan prompt dan model bahasa untuk membuat rantai
gpu_chain = prompt | gpu_llm | StrOutputParser()

question = “Apa ibu kota Indonesia?” # mendefinisikan pertanyaan

# panggil chain untuk menghasilkan dan mencetak jawaban dari pertanyaan
print(gpu_chain.invoke({“question”: question}))
```

## Batch GPU Inference

Jika dijalankan pada perangkat GPU, Anda dapat menjalankan inferensi pada GPU dalam mode batch.

* Menggunakan `HuggingFacePipeline`, Anda bisa memuat model `beomi/llama-2-ko-7b` dan mengatur agar dijalankan di GPU.
* Saat membuat `gpu_llm`, atur `batch_size` menjadi 2, `temperature` menjadi 0, dan `max_length` menjadi 64.
* Hubungkan `prompt` dan `gpu_llm` melalui sebuah pipeline untuk membuat `gpu_chain`, lalu atur token penutup menjadi "\n\n".
* Gunakan `gpu_chain.batch()` untuk menghasilkan jawaban secara paralel untuk pertanyaan-pertanyaan dalam `questions`.
* Cetak jawaban yang dihasilkan melalui loop.

```python
gpu_llm = HuggingFacePipeline.from_model_id(
    model_id="beomi/llama-2-ko-7b",  # Menentukan ID model yang akan digunakan.
    task="text-generation",  # Menetapkan tugas yang akan dilakukan.
    device=0,  # Menentukan nomor perangkat GPU. -1 berarti menggunakan CPU.
    batch_size=2,  # Menyesuaikan ukuran batch. Sesuaikan dengan memori GPU dan ukuran model.
    model_kwargs={
        "temperature": 0,
        "max_length": 256,
    },  # Menetapkan argumen tambahan yang akan diberikan ke model.
)

# Membuat chain dengan menghubungkan prompt dan model bahasa.
gpu_chain = prompt | gpu_llm.bind(stop=["\n\n"])

questions = []
for i in range(4):
    # Membuat daftar pertanyaan.
    questions.append({"question": f"Apa yang dimaksud dengan angka {i} dalam bahasa Indoensia?"})  # "Apa angka {i} dalam bahasa Indonesia?"

answers = gpu_chain.batch(questions)  # Memproses daftar pertanyaan dalam batch untuk menghasilkan jawaban.
for answer in answers:
    print(answer)
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://altero.gitbook.io/langchain-book-by-altero/ch04-model/08.-huggingface-pipeline.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.