Kejuruteraan Prompt Lanjutan: Rantai Pemikiran (COT)

keupayaan pemikiran model bahasa besar: pemikiran rantai dan teknologi lain

_Jika anda bukan ahli tetapi ingin membaca artikel ini, sila periksa pautan rakan ini. _

Pemikiran rantai (COT) telah wujud untuk beberapa waktu dan secara teknikalnya merupakan kejuruteraan tip maju, tetapi ia masih mempunyai kepentingan yang signifikan walaupun hari ini beberapa tahun selepas pengenalan pertama. Semua bentuk COT sering bertujuan untuk memaksa model bahasa yang besar untuk alasan.

Selepas OpenAI mengeluarkan versi pratonton Model O1 pada September tahun ini, kami melihat bahawa populariti di sekitar Cot telah meningkat.

Tidak ada yang tahu bagaimana O1 berfungsi (kecuali OpenAI), sama ada sistem kombinatorial, data yang digunakan untuk penalaan halus, sama ada pembelajaran tetulang digunakan, atau sama ada terdapat beberapa model yang bekerja bersama-sama.

Mungkin satu model bertanggungjawab untuk perancangan, yang lain bertanggungjawab untuk berfikir, dan yang ketiga bertanggungjawab untuk penilaian. Tetapi kita tahu mereka mengambil beberapa pendekatan penalaran langkah demi langkah.

Banyak penyelidikan awam telah dilakukan di sekitar isu ini, dan anda mungkin perlu menyelidikinya. Oleh itu, dalam jawatan ini saya akan meliputi kaedah yang sedia ada supaya anda tahu kaedah mana yang boleh anda gunakan. Sudah tentu, saya akan menguji teknologi yang berbeza untuk melihat sama ada kita boleh membuat penambahbaikan sebenar.

Kemudian, jika anda berminat melakukan beberapa kerja teknikal, saya akan membantu anda membina sistem yang melihat tahap keyakinan dalaman model untuk menghasilkan jawapan.

Hasil penyelidikan

Dalam dua tahun yang lalu, banyak kertas telah diterbitkan dan saya telah mengumpulkan banyak daripada mereka yang saya dapati di sini.

anda akan melihat teknik penalaran yang mereka bincangkan dalam gambar di bawah.

Kebanyakan kerja datang terus dari DeepMind atau Princeton University. Terima kasih kepada mereka kerana membuka banyak kerja.

Kata Katil berasal dari kertas DeepMind 2022, menggunakannya hanya dalam petunjuk, kertas terbaru meneroka pemikiran dua kali dengan carian Monte Carlo dan cot tanpa arahan.

Dalam artikel ini, kami akan memperkenalkan pemikiran rantaian mudah (COT), Cot Chaining, Decoding Greedy, Cot-SC, Decoding Cot, dan Thinking Twice (TOT) dengan Monte Carlo Tree Search.

kami juga akan menggunakan set data kami sendiri untuk memahami penambahbaikan yang boleh kami buat apabila menggunakan teknik inferensi ini.

skor asas untuk model bahasa besar

Untuk memahami bagaimana untuk meningkatkan hasil model bahasa yang besar, kita perlu menubuhkan beberapa jenis skor penanda aras.

Apabila memperkenalkan model, ia biasanya datang dengan metrik penilaian. Terdapat beberapa petunjuk popular, seperti MMLU (pemahaman bahasa), bigbench (kesimpulan), hellaswag (pemikiran akal sehat), dan sebagainya.

Walau bagaimanapun, anda harus tahu bahawa beberapa dataset ini sudah lapuk dan mungkin sedikit tercemar.

Hugging Face melancarkan ranking LLM baru pada bulan Disember, yang dinilai berdasarkan dataset yang lebih baru, dan anda dapat melihat dengan jelas bahawa kebanyakan model mempunyai skor yang lebih rendah daripada dataset asal.

Adalah patut dilakukan beberapa penyelidikan di sini untuk memahami bagaimana anda harus mempertimbangkan penilaian model dan apa sebabnya anda dan organisasi anda harus menilai. Mempunyai dataset peribadi dalaman untuk ujian mungkin bukan idea yang paling teruk.

Tetapi, saya mengekstrak kira -kira 350 soalan dari pelbagai dataset dan beberapa soalan popular yang saya dapati dalam talian untuk menilai sehingga 11 model yang berbeza.

Saya juga perlu memahami apa jawapan yang dihasilkan oleh dataset ini dan model bahasa yang besar kelihatan seperti.

jadi saya membina skrip saya sendiri untuk melengkapkan soalan -soalan ini dan kemudian menilai model bahasa yang besar menggunakan 0 atau 1 setiap soalan.

anda boleh memanggil saya perfeksionis. Anda dapat melihat apa yang saya dapati di bawah.

Apa ini memberitahu kita? Nah, tidak banyak.

Saya menggunakan soalan -soalan dari Big Bench, MMLU, Putnam, dan soalan -soalan popular seperti "berapa banyak yang ada dalam strawberi", tetapi kita tidak dapat mengetahui sama ada isu -isu ini telah dicemari oleh mereka. Tambahan pula, ini adalah dataset yang agak kecil.

Walau bagaimanapun, kita dapat melihat dengan jelas bahawa model yang lebih besar melakukan lebih baik.

Menariknya, bolehkah kita memperbaiki skor ini dengan menggunakan kaedah yang membuat alasan model dan "berfikir" sebelum jawapannya.

Pemikiran rantai (COT)

Tips Pemikiran Rantaian (COT) dicadangkan oleh pasukan otak DeepMind pada kertas "tips pemikiran rantai dalam menceritakan kesimpulan dalam model bahasa yang besar."

Idea Cot telah wujud selama beberapa waktu.

Walau bagaimanapun, kertas pertama ini adalah kajian tentang cara memaksa model untuk membuat alasan tentang masalah dengan mengaktifkan keupayaan penalaran model yang wujud dengan menggunakan strategi isyarat.

Pada masa itu, orang hanya mendorong cara yang betul dengan meminta model untuk "berfikir secara menyeluruh", yang boleh dicapai dengan sampel sifar (tidak memberikan contoh) atau beberapa sampel (menyediakan beberapa contoh).

Hari ini, anda boleh melakukan ini untuk pelbagai model seperti Claude, ChatGPT, atau model lain dengan hanya menambah "mari kita berfikir langkah demi langkah" pada akhir prompt. Jika anda ingin mencuba kurang pembelajaran sampel, anda boleh memberikan beberapa contoh dalam arahan.

DeepMind melaporkan bahawa mereka dapat mengesahkan bahawa penambahbaikan yang signifikan dalam menggunakan teknologi COT diperbaiki dengan membuat arahan dengan betul.

Sejak itu, banyak kertas telah dibina di atas teknologi ini, memanjang ke laluan yang semakin maju.

Bina rantaian penalaran

Petua ramai orang dalam komuniti kejuruteraan menggunakan teknologi gaya COT untuk bereksperimen. Saya telah mengumpul kebanyakan repositori yang saya dapati di sini, jadi mudah dicari.

Tidak lama dahulu, Benjamin Klieger menyerlahkan sesuatu yang dia membina aplikasi gaya yang menggunakan Groq dan Llama 3.1 70b untuk mendorong pemikiran rantai dengan memecah lagi proses pemikiran.

anda boleh mencari aplikasinya di sini.

Ideanya adalah untuk meminta model bahasa yang besar untuk memecah pemikirannya ke dalam rantai, dan ia akan terus berfikir sehingga ia penuh keyakinan terhadap jawapannya.

Sistem ini akan terus menjana panggilan model bahasa yang besar untuk setiap bahagian rantai, dan bukannya mempunyai keseluruhan proses pemikiran dalam satu tindak balas.

Lihat contoh memohon ini kepada Grok-Beta, soalannya ialah "Berapa banyak Rs ada di strawberi?" Model itu sendiri sedang menubuhkan setiap bahagian, menamakannya, dan memutuskan sama ada "idea" yang lain diperlukan dan harus diteruskan, atau sama ada ia telah mencapai jawapan terakhir.

Ini masih teknik gaya Cot kerana ia mempunyai hubungan linear, tetapi ia sedikit lebih maju daripada hanya meminta model untuk "berfikir langkah demi langkah".

Saya menggunakan beberapa kodnya untuk membina skrip yang melelong melalui beberapa masalah penanda aras model bahasa yang besar untuk melihat berapa banyak penambahbaikan sistem ini sebenarnya menghasilkan. Saya juga tweak claude dan skrip Grok untuk menilai strategi ini.

anda akan melihat peningkatan peratusan di bawah.

llama 3.1 70b mencapai peningkatan terbaik dalam tiga kategori pertama. Grok lebih teruk pada pandemik (seperti haiku).

dataset Putnam adalah matematik maju, dan beberapa model bahasa yang besar dapat dilakukan dengan baik dalam hal ini, jadi ketika Claude Sonnet 3.5 dapat mengatasi O1-Preview (O1-Preview) pada 68.75% dalam rantai Cot ini, saya terkejut ketika itu saya terkejut ketika itu, adalah 63%).

Keseluruhan, penggunaan COT Sonnet meningkatkan 81% dalam matematik maju.

Ingat, saya menggunakan dataset yang sangat kecil di sini, hanya untuk memahami apa yang mereka lakukan dengan baik dan sama ada kita boleh meningkatkan skor. Ia tidak memberitahu kami apa -apa yang spesifik tanpa menguji pada dataset yang lebih besar.

Walau bagaimanapun, saya juga mendapati bahawa jika model yang lebih kecil mula menganalisis masalah mudah, ia boleh menghasilkan hasil yang lebih buruk. Ini terbukti dalam isu "mudah" yang popular dari Grok-Beta dan Haiku.

Masalah yang lebih mudah bukan matematik mungkin tidak mendapat manfaat yang sama dari COT.

kita juga harus ingat bahawa kita boleh menolak model untuk bekerja dalam keupayaan mereka, tetapi jarang melebihi keupayaan mereka. Jika ia tidak tahu jawapannya, ia tidak tahu.

penalaan halus untuk penalaran

Saya ingin menyebutkan penalaan halus sebelum meneruskan.

Kawasan yang sangat menarik sedang berusaha untuk menyempurnakan model yang lebih kecil pada dataset COT untuk meningkatkan ketepatan mereka, menjadikannya mencapai ketepatan model 1-2 kali lebih besar.

Saya telah menemui pelbagai sumber, tetapi malangnya saya tidak menemui sebarang penambahbaikan yang ketara kepada model penanda aras yang saya fikir layak mendapat analisis yang betul.

anda akan melihat model sumber terbuka yang saya dapati di bawah.

Anda akan melihat dataset COT sumber terbuka yang saya dapati di bawah.

Ini bukan untuk mengatakan bahawa penalaan halus untuk Cot tidak akan berfungsi, ia hanya memerlukan membina model yang lebih baik dan didokumentasikan dengan baik.

Jika anda berminat untuk mencuba penalaan diri anda, lihat sumber-sumber ini. Saya percaya terdapat lebih banyak sumber.

Teknologi Generasi Alternatif

Setakat ini, kami telah mengkaji teknik linear model yang menghasilkan output dalam benang (atau rantai).

Teknik ini mewujudkan pelbagai laluan kesimpulan dan menggunakan beberapa kaedah untuk memilih jawapan yang paling konsisten (atau jalan) pada akhir.

Mereka melaporkan bahawa menggunakan kaedah ini telah mencapai peningkatan kira-kira 1-8% dalam penalaran aritmetik.

Kaedah yang dicadangkan tahun ini mengikuti idea yang sama menggunakan pelbagai laluan, tetapi tidak menggunakan sebarang petunjuk.

Ingat idea penyahkodan tamak yang saya bincangkan di bahagian sebelumnya?

Pendekatan ini adalah sama, kecuali bahawa ia bukan sahaja memaksa penanda yang paling mungkin, tetapi juga melihat skor keyakinan keseluruhan respons.

Untuk melakukan ini, sistem mula-mula memulakan sejumlah penanda peringkat atas awal K, dan kemudian menghasilkan jalan dari setiap penanda. Selepas jawapannya dijana, ia mengira skor keyakinan dengan menganalisis kebarangkalian (logit) setiap penanda dalam laluan yang berbeza.

mengembalikan jawapan (atau jalan) dengan kebarangkalian tertinggi.

Kaedah ini dipanggil penyahkodan katil dan dicadangkan oleh DeepMind. Idea pendekatan ini adalah untuk melihat keyakinan dalaman model dalam jawapan kembali.

Tetapi apa yang berlaku jika ia tidak mempunyai pengetahuan yang wujud untuk menjawab soalan itu? Seperti COT-SC, pendekatan ini bergantung pada sama ada model mempunyai jawapan yang betul di tempat pertama.

Walau bagaimanapun, ini tidak bermakna kita tidak boleh mengujinya.

Untuk semua teknologi ini, terdapat pelaksanaan praktikal yang berbeza di sumber terbuka, dan ini tidak terkecuali.

Jadi mudah bagi saya untuk membina sistem untuk menguji kaedah ini dan menggunakan model sumber terbuka yang lebih kecil llama 3 8b untuk membandingkan yang mana lebih baik.

Terima kasih kepada Codelion untuk sumber terbuka pelaksanaannya, yang memudahkan saya meniru.

Lihat hasil di atas, anda dapat melihat bahawa kami menggunakan penyahkodan COT untuk menghasilkan hasil yang terbaik berbanding dengan kaedah lain seperti entropi atau menggunakan penyahkodan tamak untuk model tertentu sahaja.

kami akan membuat API di bahagian teknikal yang akan menggunakan sistem penyahkodan ini supaya anda dapat memahami bagaimana ia berfungsi.

Teknologi Dikemaskini

Sukar untuk bersaing, tetapi penyelidikan telah jauh melampaui menggunakan Cot mudah untuk penalaran di kawasan risiko yang lebih tinggi.

Saya tidak akan meliputi semua strategi ini sekarang, kerana itu topik lain, tetapi saya ingin menyebut pemikiran dua kali (tot), terutamanya apabila digunakan bersama dengan Monte Carlo Search.

TOT dicadangkan oleh Princeton University dan DeepMind pada akhir tahun 2023, tetapi biasanya berdasarkan kaedah kesimpulan berasaskan pokok sebelumnya.

berfikir dua kali sebelum melakukan (TOT) agak berbeza daripada pemikiran rantaian konsisten (COT-SC). Daripada menjana pelbagai laluan dan menilai mereka selepas dihasilkan, ia secara dinamik menilai idea -idea yang telah muncul ketika ia berlangsung.

Fikirkannya sebagai 4 orang yang bekerja bersama untuk menyelesaikan masalah. Pada setiap langkah, mereka membentangkan idea mereka dan bersama -sama menilai idea -idea yang paling menjanjikan. Jika alasan seseorang seolah -olah cacat, mereka pergi, jadi yang lain akan terus bekerja pada masalah mereka.

Akhirnya, orang yang boleh membuat alasan dengan betul akan dapat memberikan jawapan mereka.

Ini membolehkan model untuk memangkas laluan secara dinamik yang kelihatan buruk, memberi tumpuan kepada benang yang lebih menjanjikan, yang berpotensi menjimatkan sumber.

Walau bagaimanapun, seseorang boleh mempersoalkan bagaimana sistem memutuskan benang mana yang betul dan benang mana yang salah? Ini ditentukan oleh model itu sendiri.

Ini adalah mengapa sambungan seperti Monte Carlo Tree Search (MCTS) menyediakan mekanisme penilaian yang lebih tidak berat sebelah. MCTS membolehkan backpropagation, yang bermaksud ia boleh meninjau semula dan meningkatkan langkah -langkah awal berdasarkan maklumat baru, sementara TOT mudah hanya akan bergerak ke hadapan.

Untuk 4 orang kes menyelesaikan masalah, MCTs akan membolehkan orang ramai mempunyai idea yang kurang daripada ideal dan masih boleh tinggal di dalam permainan lebih lama. Kaedah penilaian akan berbeza.

MCT boleh mensimulasikan pelbagai laluan masa depan, menilai potensi mereka, dan mundur untuk meningkatkan pengambilan keputusan awal. Ia memperkenalkan metrik luaran (ganjaran), bukannya bergantung sepenuhnya pada model.

Statistik seperti UCB (Batas Keyakinan Atas) Gunakan ganjaran ini untuk menentukan idea -idea yang hendak diterokai lebih lanjut atau meninjau semula.

MCTS adalah sedikit lebih rumit daripada TOT yang mudah dan boleh ditulis secara berasingan.

Ekonomi Cot

Jadi, setakat ini anda mungkin berfikir, dengan baik, kita mempunyai beberapa penambahbaikan, mengapa tidak selalu menggunakan pemikiran rantai yang lebih maju?

OK, pertama sekali, kos (dan masa untuk berfikir).

Untuk rantai yang saya gunakan untuk model yang berbeza, saya mengira bilangan purata langkah kesimpulan.

Lihat ini, anda membayar 8 kali lebih banyak setiap soalan secara purata. Bagi Sonnet, yang melakukan yang terbaik pada masalah matematik maju, anda akan membayar sehingga $ 15 setiap 500 soalan.

Ini mungkin tidak kelihatan seperti banyak, tetapi apabila anda menggunakan sistem ini untuk menghasilkan jawapan untuk perkhidmatan pelanggan anda atau pasukan anda setiap hari, anda akan menghabiskan ratusan atau bahkan beribu -ribu ringgit sebulan.

Dalam beberapa kes, masuk akal untuk menggunakan kaedah penalaran lanjutan, tetapi tidak selalu.

Mungkin ada kes sekarang bahawa penalaan halus dilakukan untuk COT, pada dasarnya menghapuskan keperluan untuk menjana pelbagai panggilan, tetapi saya tidak melihat mana-mana model sumber terbuka yang baik setakat ini.

Terdapat beberapa perdagangan di sini. Kami mahu meningkatkan masa berfikir supaya model mempunyai masa yang cukup untuk membuat alasan dengan berkesan, tetapi berbuat demikian juga akan meningkatkan kekecewaan pengguna dan kos.

Bina sistem pintar

pada bulan September tahun ini, sebuah kertas yang bertajuk "To Cot atau tidak untuk Cot?"

kita lihat ini di sini juga, dengan peningkatan terhad kepada soalan mudah.

Apabila kita menggunakan rantai ini, kita perlu menunggu lebih lama untuk mendapatkan respons. Adakah ia berbaloi? Walau bagaimanapun, perlu diperhatikan bahawa semua strategi ini boleh menjadi terlalu kompleks untuk tugas -tugas yang mudah.

inilah sebabnya anda mungkin berasa kecewa apabila menggunakan Openai's O1 dalam kebanyakan soalan, dan jawapan mudah biasanya cukup baik.

Tetapi jika anda membina sistem yang perlu memastikan jawapannya betul, mungkin idea yang baik untuk mengambil beberapa bentuk katil atau penyahkodan.

Ia mungkin bernilai menggunakan model untuk menetapkan langkah pertama berdasarkan kesukaran soalan, dan kemudian menganalisis sama ada ia yakin bahawa ia dapat menjawabnya terlebih dahulu. Kemudian biarkan model menyimpulkan (melalui rantai) dan pada akhirnya biarkan model lain menjaringkan respons.

nota

Adakah terdapat lagi rangka kerja selain apa yang saya telah diperkenalkan di sini? Sudah tentu, tetapi saya hanya memperkenalkan yang saya fikir menarik untuk difahami. Ini akan memberi anda idea tentang berapa banyak kemajuan yang telah kami buat tanpa maklumat yang berlebihan.

Kebanyakan jurutera AI berpengalaman dalam rangka kerja ini, tetapi malangnya, kajian itu tidak merebak secepat yang diharapkan kepada orang ramai.

belajar bagaimana untuk melaksanakan COT harus menjadi sebahagian daripada asas -asas aplikasi LLM, walaupun anda memutuskan untuk tidak menggunakannya.

Kerja Teknikal

marilah kita mengamalkannya.

kami akan melaksanakan sistem COT penyahkodan menggunakan model sumber terbuka Llama 3.1 8b.

Kaedah penyahkodan COT berasal dari kertas "pemikiran pemikiran rantai tanpa tip" yang dikeluarkan tahun ini, dan pelaksanaannya diperoleh dari Codelion yang terdapat di sini. Saya menambah beberapa ciri supaya sistem memeriksa tahap kesukaran untuk menentukan bilangan laluan (k).

Sejak saya menggunakan modal kali terakhir, kita boleh menggunakan Beam kali ini, yang juga merupakan platform perkhidmatan LLM tanpa pelayan. Mereka menawarkan peringkat percuma selama 15 jam, jadi percuma. Skrip yang akan kami gunakan boleh didapati di sini.

Jika anda lebih suka menggunakan colab untuk ujian, anda boleh menjalankan skrip ini di sini.

Hasilnya harus menjadi titik akhir API yang membolehkan kita bertanya soalan, yang akan menilai kesukaran, dan kemudian melakukan pengekodan katil atas soalan dan mengembalikan respons berikut.

Anda akan melihat bilangan permintaan untuk model bahasa besar dan bagaimana sistem mengklasifikasikan masalah. Anda juga akan melihat bahawa sistem ini agak lambat kerana ia menghasilkan pelbagai jawapan untuk penilaian.

Walau bagaimanapun, jika kita mencuba Groq dengan model 8B yang sama, kita akan mendapati bahawa ia tidak menjawab soalan dengan betul.

Jawapan yang betul adalah 27.3, dan mata tambahan boleh diperolehi untuk bahan bakar tambahan. Mengenai jawapan akhir, saya akan melihat bahawa walaupun model yang lebih kecil hanya boleh membawa kita setakat ini. Malangnya, dengan menggunakan model yang lebih besar memerlukan lebih banyak kerja kerana kita perlu menyimpannya di suatu tempat, yang boleh mahal.

Untuk menubuhkan sistem ini, saya akan mengambil masa 5 minit masa anda. Anda boleh mengikuti arahan di bawah.

memeluk muka

kami akan mendapat akses kepada model yang akan kami gunakan. Untuk menggunakan model Llama 3 8B, anda perlu mendapatkan akses kepadanya melalui muka yang memeluk.

Jika anda sudah mempunyai akaun muka yang memeluk, proses ini biasanya sangat cepat. Jika anda tidak mempunyai akaun, anda boleh membuat akaun secara percuma dan menavigasi ke kad model.

Apabila kita memasukkan kad model, kita juga boleh menguji model dan melihat soalan yang boleh kita gunakan untuk menguji sistem baru ini.

Ini adalah soalan yang cukup standard, saya telah menggunakannya dalam penilaian saya sebelum ini, tetapi model Llama 3 8B standard sukar dikendalikan.

Selepas anda mempunyai akses, navigasi ke tetapan untuk mendapatkan token akses.

Simpan token ini di suatu tempat kerana kita perlu menetapkannya dalam rasuk.

beam.cloud

Jika anda tidak mempunyai akaun rasuk, anda perlu membuat akaun (melainkan jika anda memilih untuk menggunakan COLAB secara langsung). Sudah tentu, anda juga boleh membina sistem anda sendiri pada platform yang berbeza.

Jika anda memutuskan untuk menggunakan rasuk, dapatkan kunci API dari papan pemuka.

### Menyediakan persekitaran

Sekarang, kita boleh mulakan. Buka terminal baru dan buat direktori baru, dan CD ke direktori itu.

<code>mkdir my-testing-dir
cd my-testing-dir</code>

klon repositori yang saya sediakan.

<code>git clone https://github.com/ilsilfverskiold/decoding-cot-beam.git </code>

Buat persekitaran maya (anda perlu memasang python untuk ini).

<code>python3 -m venv .venv && source .venv/bin/activate</code>

installe rasuk dan mengesahkan.

<code>pip install beam-client
beam configure default --token "your_token_here"</code>

Pastikan anda menyediakan hf_token yang kami dapat dari muka yang memeluk sebelum ini.

<code>beam secret create HF_TOKEN</code>

Anda boleh menyediakan perkhidmatan terus dari sini, tetapi mari kita memperkenalkan kod secara ringkas.

Jika anda tidak berminat, anda boleh melangkau bahagian seterusnya.

kod

Terdapat tiga fail python dalam folder root.

<code>│
├── app.py
├── question_classifier.py
└── cot_decoder.py </code>

Dalam app.py kita mempunyai kod dari rasuk yang membolehkan kita memuat turun berat model dari memeluk muka (pada permulaan) dan cache melalui kelantangan. Ini bermakna bahawa kali pertama kita menjalankannya, ia boleh menjadi canggung dan perlahan.

Beam juga membolehkan kami memuatkan pakej apabila skrip berjalan jauh dari rasuk.

Berikut adalah permulaan app.py dengan komen saya:

<code>[...]
# 这确保了这些包仅在脚本在 Beam 上远程运行时加载
if env.is_remote():
    import torch
    from transformers import AutoModelForCausalLM, AutoTokenizer
    from cot_decoder import cot_decode
    from question_classifier import get_k_value

# 模型参数和在卷中缓存的位置
MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
CACHE_PATH = "./cached_models2"

# 加载模型和标记器
def load_models():
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, cache_dir=CACHE_PATH)
    tokenizer.pad_token = tokenizer.eos_token
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME, device_map="auto", torch_dtype=torch.float16, cache_dir=CACHE_PATH
    )
    return model, tokenizer

# 定义端点
# 您可以指定 CPU/内存/GPU + 图像
@endpoint(
    secrets=["HF_TOKEN"],
    on_start=load_models, # 启动时加载模型以进行缓存
    name="meta-llama-3-8b-instruct",
    cpu=2,
    memory="32Gi",
    gpu="A100-40",
    image=Image(
        python_version="python3.9",
        python_packages=["torch", "transformers", "accelerate"],
    ),
    volumes=[Volume(name="cached_models2", mount_path=CACHE_PATH)],
)
[...]</code>

Kami mentakrifkan @endpoint dengan sumber yang kami mahu gunakan (A100 GPU dan 2 CPU teras). Anda juga akan melihat bahawa kami memuatkan model pada permulaan.

Selepas menerima panggilan API, kami akan menjalankan fungsi Generate_Text ().

<code>[...]

def generate_text(context: Dict[str, Any], **inputs: Dict[str, Any]) -> Dict[str, Any]:
    # 从 on_start 检索模型和标记器
    model, tokenizer = context.on_start_value

    # 根据问题的复杂性获取自适应 k 值
    classification_type = None
    if k is None:
        k, classification_type = get_k_value(messages, context)

    try:
        output_text, confidence, llm_calls = cot_decode(
            model=model,
            tokenizer=tokenizer,
            messages=messages,
            k=k,  # 使用自适应 k 值
            **inputs  # 将任何其他参数直接传递给 cot_decode
        )

        # 返回输出
        return {
            "output": output_text,
            "confidence": confidence,
            "complexity_info": {
                "k": k,
                "total_calls": llm_calls + 1,  # + 分类调用
                "classification": classification_type
            }
        }
    except Exception as e:
        return {"error": f"Error during generation: {str(e)}"}</code>

Kami mempunyai fungsi yang pertama menggunakan get_k_value () untuk mengira k berdasarkan kerumitan. Tetapi fungsi utama di sini ialah COT_DECODE (), yang akan melakukan pemikiran rantaian penyahkodan mengenai masalah kami.

Fungsi ini akan menerima mesej, model, dan tokenizer dan membuat panggilan awal pertama untuk meramalkan kemungkinan tag seterusnya menggunakan logit tertinggi.

Logit

adalah skor asal yang diberikan oleh model untuk setiap penanda seterusnya yang mungkin, memberitahu kami skor keyakinan model untuk setiap pilihan.

Ini akan berfungsi sebagai titik permulaan yang berpotensi untuk menghasilkan pelbagai jawapan. Bagi setiap titik permulaan atau tanda permulaan ini, kami menghasilkan jawapan yang lengkap dan kemudian menilai secara keseluruhan.

Ingat penyahkodan tamak yang kita bincangkan? Jika kebarangkalian tag seterusnya adalah tinggi, kita hanya menjana? Ini akan melihat keseluruhan kalimat dengan mengira skor keyakinan yang mencerminkan tahap yang mana model menentukan jawapan penuh, dan bukannya menandakan satu demi satu.

Selepas mendapatkan laluan dengan skor keyakinan tertinggi, ia akan dikembalikan dengan nilai K.

Terdapat beberapa pilihan lain, seperti menambah agregat_answers bool apabila model mengembalikan banyak jawapan keyakinan tinggi, tetapi kami tidak menggunakannya di sini.

mari kita jalankan

Sekarang saya telah menjelaskan secara ringkas kod itu, kita akan menjalankannya untuk melihat bagaimana ia berfungsi.

Jika anda mempunyai segala -galanya dengan betul, anda sepatutnya dapat memanggil servis.

<code>beam serve app.py:generate_text</code>

Jika tamat masa, lari berkhidmat lagi dan ia akan cache model untuk anda.

Untuk melihat di mana model disimpan, anda boleh pergi ke volum dalam platform beam.cloud.

Sebaik sahaja ia berjalan, anda akan melihat yang berikut.

Ini bermakna ia bersedia untuk ujian.

anda boleh memulakan postman atau menggunakan curl (yang bermaksud anda menjalankan panggilan ke titik akhir dalam tetingkap terminal)

<code>mkdir my-testing-dir
cd my-testing-dir</code>

Tanggapan harus sama dengan yang berikut.

Seperti yang anda lihat, ia melakukan sedikit lebih baik.

Jika anda ingin menggunakan model, anda hanya boleh menjalankan penggunaan.

<code>git clone https://github.com/ilsilfverskiold/decoding-cot-beam.git </code>

Saya hanya menggunakannya untuk mengujinya, jadi saya boleh mematikannya sekarang.

Saya harap artikel ini pendidikan dan menarik, dan anda akan mendapat sesuatu.

Jika anda ingin melihat hasil untuk model bahasa dan teknologi COT yang besar, anda boleh melihat jadual ini dan semua sumber lain yang anda dapati dalam repositori ini.

Jika ia membantu anda, sila tinggalkan komen dan memuji saya.

❤

Atas ialah kandungan terperinci Kejuruteraan Prompt Lanjutan: Rantai Pemikiran (COT). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!