Mengintegrasikan alur prompt dengan DevOps aplikasi berbasis LLM

Dalam artikel ini, Anda mempelajari tentang integrasi alur prompt dengan DevOps aplikasi berbasis LLM di Azure Pembelajaran Mesin. Alur prompt menawarkan pengalaman code-first yang ramah pengembang dan mudah digunakan untuk pengembangan alur dan iterasi dengan seluruh alur kerja pengembangan aplikasi berbasis LLM Anda.

Ini menyediakan alur prompt SDK dan CLI, ekstensi kode VS, dan UI baru penjelajah folder alur untuk memfasilitasi pengembangan alur lokal, pemicu lokal eksekusi alur dan evaluasi berjalan, dan alur transisi dari lingkungan lokal ke cloud (Azure Pembelajaran Mesin ruang kerja).

Dokumentasi ini berfokus pada cara menggabungkan kemampuan pengalaman kode alur yang cepat dan DevOps secara efektif untuk meningkatkan alur kerja pengembangan aplikasi berbasis LLM Anda.

Pengenalan pengalaman kode-pertama dalam alur perintah

Saat mengembangkan aplikasi menggunakan LLM, umumnya memiliki proses rekayasa aplikasi standar yang mencakup repositori kode dan alur CI/CD. Integrasi ini memungkinkan proses pengembangan, kontrol versi, dan kolaborasi yang disederhanakan di antara anggota tim.

Untuk pengembang yang berpengalaman dalam pengembangan kode yang mencari proses iterasi LLMOps yang lebih efisien, fitur dan manfaat utama berikut yang dapat Anda peroleh dari pengalaman kode alur yang cepat:

• Penerapan versi alur dalam repositori kode. Anda dapat menentukan alur Anda dalam format YAML, yang dapat tetap selaras dengan file sumber yang direferensikan dalam struktur folder.
• Integrasikan eksekusi alur dengan alur CI/CD. Anda dapat memicu eksekusi alur menggunakan aliran perintah CLI atau SDK, yang dapat diintegrasikan dengan mulus ke dalam alur CI/CD dan proses pengiriman Anda.
• Transisi yang lancar dari lokal ke cloud. Anda dapat dengan mudah mengekspor folder alur Anda ke repositori lokal atau kode Anda untuk kontrol versi, pengembangan lokal, dan berbagi. Demikian pula, folder alur dapat dengan mudah diimpor kembali ke cloud untuk penulisan, pengujian, penyebaran lebih lanjut di sumber daya cloud.

Mengakses definisi kode alur perintah

Setiap alur setiap alur prompt dikaitkan dengan struktur folder alur yang berisi file penting untuk menentukan alur dalam struktur folder kode. Struktur folder ini mengatur alur Anda, memfasilitasi transisi yang lebih lancar.

Azure Pembelajaran Mesin menawarkan sistem file bersama untuk semua pengguna ruang kerja. Setelah membuat alur, folder alur yang sesuai secara otomatis dihasilkan dan disimpan di sana, yang terletak di Users/<username>/promptflow direktori.

Struktur folder alur

Gambaran umum struktur folder alur dan file kunci yang dikandungnya:

• flow.dag.yaml: File definisi alur utama ini, dalam format YAML, mencakup informasi tentang input, output, simpul, alat, dan varian yang digunakan dalam alur. Ini integral untuk menulis dan menentukan alur prompt.
• File kode sumber (.py, .jinja2): Folder alur juga menyertakan file kode sumber yang dikelola pengguna, yang dirujuk oleh alat/simpul dalam alur.
  • File dalam format Python (.py) dapat direferensikan oleh alat python untuk menentukan logika python kustom.
  • File dalam format Jinja 2 (.jinja2) dapat direferensikan oleh alat prompt atau alat LLM untuk menentukan konteks prompt.
• File non-sumber: Folder alur juga dapat berisi file nonsource seperti file utilitas dan file data yang dapat disertakan dalam file sumber.

Setelah alur dibuat, Anda dapat menavigasi ke Halaman Penulisan Alur untuk melihat dan mengoperasikan file alur di penjelajah file yang tepat. Ini memungkinkan Anda untuk melihat, mengedit, dan mengelola file Anda. Setiap modifikasi yang dilakukan pada file secara langsung tercermin dalam penyimpanan berbagi file.

Dengan mengaktifkan "Mode file mentah", Anda dapat melihat dan mengedit konten mentah file di editor file, termasuk file flow.dag.yaml definisi alur dan file sumber.

Atau, Anda dapat mengakses semua folder alur langsung dalam buku catatan Azure Pembelajaran Mesin.

Alur permintaan penerapan versi di repositori kode

Untuk memeriksa alur Anda ke repositori kode, Anda dapat dengan mudah mengekspor folder alur dari halaman penulisan alur ke sistem lokal Anda. Ini mengunduh paket yang berisi semua file dari penjelajah ke komputer lokal Anda, yang kemudian dapat Anda periksa ke repositori kode Anda.

Untuk informasi selengkapnya tentang integrasi DevOps dengan Azure Pembelajaran Mesin, lihat Integrasi Git di Azure Pembelajaran Mesin

Mengirimkan eksekusi ke cloud dari repositori lokal

Prasyarat

• Selesaikan buat sumber daya untuk memulai jika Anda belum memiliki ruang kerja Azure Pembelajaran Mesin.

• Lingkungan Python tempat Anda menginstal Azure Pembelajaran Mesin Python SDK v2 - instruksi penginstalan. Lingkungan ini untuk menentukan dan mengontrol sumber daya Azure Pembelajaran Mesin Anda dan terpisah dari lingkungan yang digunakan pada sesi komputasi. Untuk mempelajari lebih lanjut, lihat cara mengelola sesi komputasi untuk rekayasa alur yang cepat.

Menginstal SDK alur prompt

pip install -r ../../examples/requirements.txt

Sambungkan ke ruang kerja Azure Machine Learning

Azure CLI

az login

Python SDK

import json

# Import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# azure version promptflow apis
from promptflow.azure import PFClient

# Configure credential
try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

# Get a handle to workspace, it will use config.json in current and parent directory.
pf = PFClient.from_config(
    credential=credential,
)

Azure CLI

Siapkan run.yml untuk menentukan konfigurasi untuk alur ini yang dijalankan di cloud.

$schema: https://azuremlschemas.azureedge.net/promptflow/latest/Run.schema.json
flow: <path_to_flow>
data: <path_to_flow>/data.jsonl

column_mapping:
  url: ${data.url}

# define cloud resource

# if using serverless compute type
# resources:
#   instance_type: <instance_type> 

# if using compute instance compute type
# resources:
#   compute: <compute_instance_name> 

# overrides connections 
connections:
  classify_with_llm:
    connection: <connection_name>
    deployment_name: <deployment_name>
  summarize_text_content:
    connection: <connection_name>
    deployment_name: <deployment_name>

Anda dapat menentukan nama koneksi dan penyebaran untuk setiap alat dalam alur. Jika Anda tidak menentukan nama koneksi dan penyebaran, itu menggunakan satu koneksi dan penyebaran pada flow.dag.yaml file. Untuk memformat koneksi:

...
connections:
  <node_name>:
    connection: <connection_name>
      deployment_name: <deployment_name>
...

pfazure run create --file run.yml

Python SDK

# load flow
flow = "<path_to_flow>"
data = "<path_to_flow>/data.jsonl"


# define cloud resource

# define instance type when using serverless compute type
# resources = {"instance_type": <instance_type>}

# specify the compute instance name when using compute instance compute type
# resources = {"compute": <compute_instance_name>}

# overrides connections 
connections = {"classify_with_llm":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>},
               "summarize_text_content":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>}
                }
# create run
base_run = pf.run(
    flow=flow,
    data=data,
#    resources = resources,
    column_mapping={
        "url": "${data.url}"
    }, 
    connections=connections,  

)
print(base_run)

Azure CLI

run_evaluation.yml Siapkan untuk menentukan konfigurasi untuk alur evaluasi ini yang dijalankan di cloud.

$schema: https://azuremlschemas.azureedge.net/promptflow/latest/Run.schema.json
flow: <path_to_flow>
data: <path_to_flow>/data.jsonl
run: <id of web-classification flow run>
column_mapping:
  groundtruth: ${data.answer}
  prediction: ${run.outputs.category}

# define cloud resource

# if using serverless compute type
# resources:
#   instance_type: <instance_type> 

# if using compute instance compute type
# resources:
#   compute: <compute_instance_name> 


# overrides connections 
connections:
  classify_with_llm:
    connection: <connection_name>
    deployment_name: <deployment_name>
  summarize_text_content:
    connection: <connection_name>
    deployment_name: <deployment_name>

pfazure run create --file run_evaluation.yml

Python SDK

# load flow
flow = "<path_to_flow>"
data = "<path_to_flow>/data.jsonl"

# define cloud resource

# define instance type when using serverless compute type
# resources = {"instance_type": <instance_type>}

# specify the compute instance name when using compute instance compute type
# resources = {"compute": <compute_instance_name>}

# overrides connections 
connections = {"classify_with_llm":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>},
               "summarize_text_content":
                  {"connection": <connection_name>,
                  "deployment_name": <deployment_name>}
                }

# create evaluation run
eval_run = pf.run(
    flow=flow
    data=data,
    run=base_run,
    column_mapping={
        "groundtruth": "${data.answer}",
        "prediction": "${run.outputs.category}",
    },
#    resources = resources, 
    connections=connections
)

Menampilkan hasil eksekusi di ruang kerja Azure Pembelajaran Mesin

Kirim alur yang dijalankan ke cloud akan mengembalikan url portal eksekusi. Anda dapat membuka tampilan uri hasil eksekusi di portal.

Anda juga dapat menggunakan perintah berikut untuk melihat hasil eksekusi.

Mengalirkan log

Azure CLI

pfazure run stream --name <run_name>

Python SDK

pf.stream("<run_name>")

Melihat output eksekusi

Azure CLI

pfazure run show-details --name <run_name>

Python SDK

details = pf.get_details(eval_run)
details.head(10)

Melihat metrik eksekusi evaluasi

Azure CLI

pfazure run show-metrics --name <evaluation_run_name>

Python SDK

pf.get_metrics("evaluation_run_name")

Penting

Untuk informasi selengkapnya, Anda dapat merujuk ke dokumentasi CLI alur perintah untuk Azure.

Pengembangan berulang dari penyempurnaan

Fitur pengembangan dan pengujian

Selama pengembangan berulang, saat Anda menyempurnakan dan menyempurnakan alur atau perintah Anda, mungkin bermanfaat untuk melakukan beberapa iterasi secara lokal dalam repositori kode Anda. Versi komunitas, ekstensi VS Code alur cepat dan alur prompt SDK lokal & CLI disediakan untuk memfasilitasi pengembangan dan pengujian lokal murni tanpa pengikatan Azure.

Ekstensi Visual Studio Code alur perintah

Dengan ekstensi VISUAL Code alur perintah terinstal, Anda dapat dengan mudah menulis alur Anda secara lokal dari editor Visual Studio Code, memberikan pengalaman UI serupa seperti di cloud.

Untuk menggunakan ekstensi:

1. Buka folder alur perintah di Visual Studio Code Desktop.
2. Buka file '''flow.dag.yaml'' dalam tampilan buku catatan.
3. Gunakan editor visual untuk membuat perubahan yang diperlukan pada alur Anda, seperti menyetel perintah dalam varian, atau menambahkan lebih banyak alat.
4. Untuk menguji alur Anda, pilih tombol Jalankan Alur di bagian atas editor visual. Ini memicu pengujian alur.

Prompt flow SDK lokal & CLI

Jika Anda lebih suka menggunakan Jupyter, PyCharm, Visual Studio, atau IDEs lainnya, Anda dapat langsung memodifikasi definisi YAML dalam flow.dag.yaml file.

Anda kemudian dapat memicu eksekusi tunggal alur untuk pengujian menggunakan CLI atau SDK alur perintah.

Azure CLI

Dengan asumsi Anda berada dalam direktori kerja <path-to-the-sample-repo>/examples/flows/standard/

pf flow test --flow web-classification  # "web-classification" is the directory name

Python SDK

Nilai test pengembalian fungsi adalah output alur/simpul.

from promptflow import PFClient

pf_client = PFClient()

flow_path = "web-classification"  # "web-classification" is the directory name

# Test flow
flow_inputs = {"url": "https://www.youtube.com/watch?v=o5ZQyXaAv1g", "answer": "Channel", "evidence": "Url"}  # The inputs of the flow.
flow_result = pf_client.test(flow=flow_path, inputs=inputs)
print(f"Flow outputs: {flow_result}")

# Test node in the flow
node_name = "fetch_text_content_from_url"  # The node name in the flow.
node_inputs = {"url": "https://www.youtube.com/watch?v=o5ZQyXaAv1g"}  # The inputs of the node.
node_result = pf_client.test(flow=flow_path, inputs=node_inputs, node=node_name)
print(f"Node outputs: {node_result}")

Ini memungkinkan Anda untuk membuat dan menguji perubahan dengan cepat, tanpa perlu memperbarui repositori kode utama setiap kali. Setelah puas dengan hasil pengujian lokal, Anda kemudian dapat mentransfer untuk mengirimkan eksekusi ke cloud dari repositori lokal untuk melakukan eksperimen yang berjalan di cloud.

Untuk detail dan panduan selengkapnya tentang menggunakan versi lokal, Anda dapat merujuk ke alur permintaan komunitas GitHub.

Kembali ke antarmuka pengguna studio untuk pengembangan berkelanjutan

Atau, Anda memiliki opsi untuk kembali ke antarmuka pengguna studio, menggunakan sumber daya dan pengalaman cloud untuk membuat perubahan pada alur Anda di halaman penulisan alur.

Untuk terus mengembangkan dan bekerja dengan versi terbaru file alur, Anda dapat mengakses terminal di buku catatan dan menarik perubahan terbaru file alur dari repositori Anda.

Selain itu, jika Anda lebih suka terus bekerja di antarmuka pengguna studio, Anda dapat langsung mengimpor folder alur lokal sebagai alur draf baru. Ini memungkinkan Anda untuk transisi antara pengembangan lokal dan cloud dengan lancar.

Integrasi CI/CD

CI: Alur pemicu berjalan di alur CI

Setelah Anda berhasil mengembangkan dan menguji alur Anda, dan memeriksanya sebagai versi awal, Anda siap untuk iterasi penyetelan dan pengujian berikutnya. Pada tahap ini, Anda dapat memicu eksekusi alur, termasuk pengujian batch dan evaluasi berjalan, menggunakan CLI alur perintah. Ini dapat berfungsi sebagai alur kerja otomatis dalam alur Integrasi Berkelanjutan (CI) Anda.

Sepanjang siklus hidup iterasi alur Anda, beberapa operasi dapat diotomatisasi:

• Menjalankan alur prompt setelah Permintaan Pull
• Menjalankan evaluasi alur prompt untuk memastikan hasil berkualitas tinggi
• Mendaftarkan model alur perintah
• Penyebaran model alur prompt

Untuk panduan komprehensif tentang alur MLOps end-to-end yang menjalankan alur klasifikasi web, lihat Menyiapkan LLMOps ujung ke ujung dengan Alur dan GitHub yang diminta, dan proyek demo GitHub.

CD: Penyebaran berkelanjutan

Langkah terakhir untuk masuk ke produksi adalah menyebarkan alur Anda sebagai titik akhir online di Azure Pembelajaran Mesin. Ini memungkinkan Anda untuk mengintegrasikan alur Anda ke dalam aplikasi Anda dan membuatnya tersedia untuk digunakan.

Untuk informasi selengkapnya tentang cara menyebarkan alur Anda, lihat Menyebarkan alur ke titik akhir online terkelola Azure Pembelajaran Mesin untuk inferensi real time dengan CLI dan SDK.

Berkolaborasi pada pengembangan alur dalam produksi

Dalam konteks pengembangan aplikasi berbasis LLM dengan alur prompt, kolaborasi antar anggota tim sering kali penting. Anggota tim mungkin terlibat dalam penulisan dan pengujian alur yang sama, mengerjakan berbagai aspek alur atau membuat perubahan berulang dan peningkatan secara bersamaan.

Kolaborasi tersebut memerlukan pendekatan yang efisien dan efisien untuk berbagi kode, melacak modifikasi, mengelola versi, dan mengintegrasikan perubahan ini ke dalam proyek akhir.

Pengenalan alur prompt SDK/CLI dan Ekstensi Visual Studio Code sebagai bagian dari pengalaman kode alur prompt memfasilitasi kolaborasi yang mudah pada pengembangan alur dalam repositori kode Anda. Dianjurkan untuk menggunakan repositori kode berbasis cloud, seperti GitHub atau Azure DevOps, untuk melacak perubahan, mengelola versi, dan mengintegrasikan modifikasi ini ke dalam proyek akhir.

Praktik terbaik untuk pengembangan kolaboratif

1. Penulisan dan pengujian tunggal alur Anda secara lokal - Repositori kode dan Ekstensi VSC

   • Langkah pertama dari proses kolaboratif ini melibatkan penggunaan repositori kode sebagai dasar untuk kode proyek Anda, yang mencakup kode alur perintah.
     • Repositori terpusat ini memungkinkan organisasi yang efisien, melacak semua perubahan kode, dan kolaborasi di antara anggota tim.
   • Setelah repositori disiapkan, anggota tim dapat menggunakan ekstensi VSC untuk penulisan lokal dan pengujian input tunggal alur.
     • Lingkungan pengembangan terintegrasi terstandarisasi ini menumbuhkan kolaborasi di antara beberapa anggota yang bekerja pada berbagai aspek alur.

2. Pengujian dan evaluasi batch eksperimental berbasis cloud - alur prompt CLI/SDK dan UI portal ruang kerja

   • Setelah fase pengembangan dan pengujian lokal, pengembang alur dapat menggunakan Pfazure CLI atau SDK untuk mengirimkan eksekusi batch dan evaluasi yang dijalankan dari file alur lokal ke cloud.
     • Tindakan ini menyediakan cara untuk mengonsumsi sumber daya cloud, hasilnya disimpan secara terus-menerus dan dikelola secara efisien dengan UI portal di ruang kerja Azure Pembelajaran Mesin. Langkah ini memungkinkan konsumsi sumber daya cloud termasuk komputasi dan penyimpanan dan titik akhir lebih lanjut untuk penyebaran.
   • Pasca pengiriman ke cloud, anggota tim dapat mengakses UI portal cloud untuk melihat hasilnya dan mengelola eksperimen secara efisien.
     • Ruang kerja cloud ini menyediakan lokasi terpusat untuk mengumpulkan dan mengelola semua riwayat eksekusi, log, rekam jepret, hasil komprehensif termasuk input dan output tingkat instans.
     • Dalam daftar eksekusi yang mencatat semua riwayat eksekusi dari selama pengembangan, anggota tim dapat dengan mudah membandingkan hasil eksekusi yang berbeda, membantu dalam analisis kualitas dan penyesuaian yang diperlukan.

3. Pengembangan berulang lokal atau penyebaran UI satu langkah untuk produksi

   • Setelah analisis eksperimen, anggota tim dapat kembali ke repositori kode untuk pengembangan lain dan penyempurnaan. Eksekusi berikutnya kemudian dapat dikirimkan ke cloud dengan cara berulang.
     • Pendekatan iteratif ini memastikan peningkatan yang konsisten sampai tim puas dengan kualitas yang siap untuk produksi.
   • Setelah tim sepenuhnya yakin dengan kualitas alur, tim dapat disebarkan dengan mulus melalui wizard UI sebagai titik akhir online di Azure Pembelajaran Mesin. Setelah tim sepenuhnya yakin dengan kualitas alur, tim dapat beralih ke produksi dengan mulus melalui wizard penyebaran UI sebagai titik akhir online di lingkungan cloud yang kuat.
     • Penyebaran ini pada titik akhir online dapat didasarkan pada rekam jepret yang dijalankan, memungkinkan penyajian yang stabil dan aman, alokasi sumber daya dan pelacakan penggunaan lebih lanjut, dan pemantauan log di cloud.

Mengapa kami merekomendasikan penggunaan repositori kode untuk pengembangan kolaboratif

Untuk pengembangan berulang, kombinasi lingkungan pengembangan lokal dan sistem kontrol versi, seperti Git, biasanya lebih efektif. Anda dapat melakukan modifikasi dan menguji kode Anda secara lokal, lalu menerapkan perubahan pada Git. Ini membuat catatan yang sedang berlangsung dari perubahan Anda dan menawarkan kemampuan untuk kembali ke versi sebelumnya jika perlu.

Saat berbagi mengalir di berbagai lingkungan diperlukan, menggunakan repositori kode berbasis cloud seperti GitHub atau Azure Repos disarankan. Ini memungkinkan Anda mengakses versi terbaru kode Anda dari lokasi mana pun dan menyediakan alat untuk kolaborasi dan manajemen kode.

Dengan mengikuti praktik terbaik ini, tim dapat menciptakan lingkungan kolaboratif yang mulus, efisien, dan produktif untuk pengembangan alur yang cepat.

Langkah berikutnya

• Menyiapkan LLMOps end-to-end dengan alur prompt dan GitHub
• Dokumentasi CLI alur prompt untuk Azure