Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Evaluasi RFT **catatan** Evaluasi melalui fungsi hadiah jarak jauh di AWS lingkungan Anda sendiri hanya tersedia jika Anda adalah pelanggan Amazon Nova Forge. **penting** Bidang `rl_env` konfigurasi digunakan secara eksklusif untuk evaluasi, bukan untuk pelatihan. Selama pelatihan, Anda mengonfigurasi fungsi reward menggunakan infrastruktur `reward_lambda_arn` (single-turn) atau BYOO dengan `rollout.delegate: true` (multi-turn). **Apa itu Evaluasi RFT?** Evaluasi RFT memungkinkan Anda menilai kinerja model Anda menggunakan fungsi hadiah khusus sebelum, selama, atau setelah pelatihan pembelajaran penguatan. Tidak seperti evaluasi standar yang menggunakan metrik yang telah ditentukan sebelumnya, Evaluasi RFT memungkinkan Anda menentukan kriteria keberhasilan Anda sendiri melalui fungsi Lambda yang menilai output model berdasarkan kebutuhan spesifik Anda. **Mengapa Evaluasi dengan RFT?** Evaluasi sangat penting untuk menentukan apakah proses fine-tuning RL memiliki: + Penyelarasan model yang ditingkatkan dengan kasus penggunaan spesifik Anda dan nilai-nilai kemanusiaan + Mempertahankan atau meningkatkan kemampuan model pada tugas-tugas utama + Menghindari efek samping yang tidak diinginkan seperti berkurangnya faktualitas, peningkatan verbositas, atau penurunan kinerja pada tugas-tugas lain + Memenuhi kriteria keberhasilan khusus Anda seperti yang ditentukan oleh fungsi hadiah Anda **Kapan Menggunakan Evaluasi RFT** Gunakan Evaluasi RFT dalam skenario ini: + Sebelum Pelatihan RFT: Tetapkan metrik dasar pada kumpulan data evaluasi Anda + Selama Pelatihan RFT: Pantau kemajuan pelatihan dengan pos pemeriksaan menengah + Setelah Pelatihan RFT: Validasi bahwa model akhir memenuhi kebutuhan Anda + Membandingkan Model: Mengevaluasi beberapa versi model menggunakan kriteria hadiah yang konsisten **catatan** Gunakan Evaluasi RFT saat Anda membutuhkan metrik khusus domain khusus. Untuk evaluasi tujuan umum (akurasi, kebingungan, BLEU), gunakan metode evaluasi standar. **Topics** + [Persyaratan format data](#nova-hp-evaluate-rft-data-format) + [Mempersiapkan resep evaluasi Anda](#nova-hp-evaluate-rft-recipe) + [Fungsi hadiah preset](#nova-hp-evaluate-rft-preset) + [Membuat fungsi hadiah Anda](#nova-hp-evaluate-rft-create-function) + [Izin IAM](#nova-hp-evaluate-rft-iam) + [Melaksanakan pekerjaan evaluasi](#nova-hp-evaluate-rft-execution) + [Memahami hasil evaluasi](#nova-hp-evaluate-rft-results) ## Persyaratan format data **Struktur data masukan** Data input evaluasi RFT harus mengikuti format Fine-Tuning Penguatan OpenAI. Setiap contoh adalah objek JSON yang berisi: + `messages`: Array giliran percakapan dengan `system` dan peran `user` + Metadata opsional lainnya, misalnya reference\_answer **Contoh format data** Contoh berikut menunjukkan format yang diperlukan: ``` { "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13" } ] } ], "reference_answer": { "x": 4 } } ``` **Keterbatasan saat ini** Batasan berikut berlaku untuk evaluasi RFT: + Hanya teks: Tidak ada input multimodal (gambar, audio, video) yang didukung + Percakapan satu putaran: Hanya mendukung pesan pengguna tunggal (tidak ada dialog multi-putaran) + Format JSON: Data input harus dalam format JSONL (satu objek JSON per baris) + Output model: Evaluasi dilakukan pada penyelesaian yang dihasilkan dari model yang ditentukan ## Mempersiapkan resep evaluasi Anda **Contoh konfigurasi resep** Contoh berikut menunjukkan resep evaluasi RFT lengkap: ``` run: name: nova-lite-rft-eval-job model_type: amazon.nova-lite-v1:0:300k model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for SageMaker HyperPod jobs data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results evaluation: task: rft_eval # [FIXED] Do not modify strategy: rft_eval # [FIXED] Do not modify metric: all # [FIXED] Do not modify # Inference Configuration inference: max_new_tokens: 8196 # [MODIFIABLE] Maximum tokens to generate top_k: -1 # [MODIFIABLE] Top-k sampling parameter top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic) top_logprobs: 0 # Evaluation Environment Configuration (NOT used in training) rl_env: reward_lambda_arn: arn:aws:lambda:::function: ``` ## Fungsi hadiah preset Dua fungsi hadiah preset (`prime_code`dan`prime_math`) tersedia sebagai lapisan Lambda untuk memudahkan integrasi dengan fungsi Lambda RFT Anda. **Ikhtisar** Fungsi preset ini memberikan kemampuan out-of-the-box evaluasi untuk: + **prime\_code: Pembuatan** kode dan evaluasi kebenaran + **prime\_math: Penalaran matematis** dan evaluasi pemecahan masalah **Pengaturan cepat** Untuk menggunakan fungsi hadiah preset: 1. [Unduh layer Lambda dari rilis nova-custom-eval-sdk](https://github.com/aws/nova-custom-eval-sdk/releases) 1. Publikasikan lapisan Lambda menggunakan CLI AWS : ``` aws lambda publish-layer-version \ --layer-name preset-function-layer \ --description "Preset reward function layer with dependencies" \ --zip-file fileb://universal_reward_layer.zip \ --compatible-runtimes python3.9 python3.10 python3.11 python3.12 \ --compatible-architectures x86_64 arm64 ``` 1. Tambahkan layer ke fungsi Lambda Anda di AWS Console (Pilih preset-function-layer dari lapisan kustom dan juga tambahkan AWSSDKPandas-Python 312 untuk dependensi numpy) 1. Impor dan gunakan dalam kode Lambda Anda: ``` from prime_code import compute_score # For code evaluation from prime_math import compute_score # For math evaluation ``` **fungsi prime\_code** **Tujuan**: Mengevaluasi tugas pembuatan kode Python dengan mengeksekusi kode terhadap kasus uji dan mengukur kebenaran. **Contoh format dataset masukan dari evaluasi**: ``` {"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}} {"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}} ``` **Fitur utama**: + Ekstraksi kode otomatis dari blok kode penurunan harga + Deteksi fungsi dan pengujian berbasis panggilan + Eksekusi kasus uji dengan perlindungan batas waktu + Validasi sintaks dan pemeriksaan kompilasi + Pelaporan kesalahan terperinci dengan traceback **fungsi prime\_math** **Tujuan**: Mengevaluasi penalaran matematika dan kemampuan pemecahan masalah dengan dukungan matematika simbolis. **Format masukan**: ``` {"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"} ``` **Fitur utama**: + Evaluasi matematika simbolik menggunakan SymPy + Beberapa format jawaban (LaTeX, teks biasa, simbolis) + Pemeriksaan kesetaraan matematika + Normalisasi dan penyederhanaan ekspresi **Praktik terbaik** Ikuti praktik terbaik ini saat menggunakan fungsi hadiah preset: + Gunakan tipe data yang tepat dalam kasus uji (bilangan bulat vs string, boolean vs “True”) + Berikan tanda tangan fungsi yang jelas dalam masalah kode + Sertakan kasus tepi dalam input pengujian (nol, angka negatif, input kosong) + Format ekspresi matematika secara konsisten dalam jawaban referensi + Uji fungsi reward Anda dengan data sampel sebelum penerapan ## Membuat fungsi hadiah Anda **Lambda ARN** Anda harus merujuk ke format berikut untuk Lambda ARN: ``` "arn:aws:lambda:*:*:function:*SageMaker*" ``` Jika Lambda tidak memiliki skema penamaan ini, pekerjaan akan gagal dengan kesalahan ini: ``` [ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn) ``` **Struktur fungsi Lambda** Fungsi Lambda Anda menerima batch output model dan mengembalikan skor hadiah. Di bawah ini adalah contoh implementasi: ``` from typing import List, Any import json import re from dataclasses import asdict, dataclass @dataclass class MetricResult: """Individual metric result.""" name: str value: float type: str @dataclass class RewardOutput: """Reward service output.""" id: str aggregate_reward_score: float metrics_list: List[MetricResult] def lambda_handler(event, context): """ Main lambda handler """ return lambda_grader(event) def lambda_grader(samples: list[dict]) -> list[dict]: """ Core grader function """ scores: List[RewardOutput] = [] for sample in samples: print("Sample: ", json.dumps(sample, indent=2)) # Extract components idx = sample.get("id", "no id") if not idx or idx == "no id": print(f"ID is None/empty for sample: {sample}") ground_truth = sample.get("reference_answer") if "messages" not in sample: print(f"Messages is None/empty for id: {idx}") continue if ground_truth is None: print(f"No answer found in ground truth for id: {idx}") continue # Get model's response (last turn is assistant turn) last_message = sample["messages"][-1] if last_message["role"] != "nova_assistant": print(f"Last message is not from assistant for id: {idx}") continue if "content" not in last_message: print(f"Completion text is empty for id: {idx}") continue model_text = last_message["content"] # --- Actual scoring logic (lexical overlap) --- ground_truth_text = _extract_ground_truth_text(ground_truth) # Calculate main score and individual metrics overlap_score = _lexical_overlap_score(model_text, ground_truth_text) # Create two separate metrics as in the first implementation accuracy_score = overlap_score # Use overlap as accuracy fluency_score = _calculate_fluency(model_text) # New function for fluency # Create individual metrics metrics_list = [ MetricResult(name="accuracy", value=accuracy_score, type="Metric"), MetricResult(name="fluency", value=fluency_score, type="Reward") ] ro = RewardOutput( id=idx, aggregate_reward_score=overlap_score, metrics_list=metrics_list ) print(f"Response for id: {idx} is {ro}") scores.append(ro) # Convert to dict format result = [] for score in scores: result.append({ "id": score.id, "aggregate_reward_score": score.aggregate_reward_score, "metrics_list": [asdict(metric) for metric in score.metrics_list] }) return result def _extract_ground_truth_text(ground_truth: Any) -> str: """ Turn the `ground_truth` field into a plain string. """ if isinstance(ground_truth, str): return ground_truth if isinstance(ground_truth, dict): # Common patterns: { "explanation": "...", "answer": "..." } if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str): return ground_truth["explanation"] if "answer" in ground_truth and isinstance(ground_truth["answer"], str): return ground_truth["answer"] # Fallback: stringify the whole dict return json.dumps(ground_truth, ensure_ascii=False) # Fallback: stringify anything else return str(ground_truth) def _tokenize(text: str) -> List[str]: # Very simple tokenizer: lowercase + alphanumeric word chunks return re.findall(r"\w+", text.lower()) def _lexical_overlap_score(model_text: str, ground_truth_text: str) -> float: """ Simple lexical overlap score in [0, 1]: score = |tokens(model) ∩ tokens(gt)| / |tokens(gt)| """ gt_tokens = _tokenize(ground_truth_text) model_tokens = _tokenize(model_text) if not gt_tokens: return 0.0 gt_set = set(gt_tokens) model_set = set(model_tokens) common = gt_set & model_set return len(common) / len(gt_set) def _calculate_fluency(text: str) -> float: """ Calculate a simple fluency score based on: - Average word length - Text length - Sentence structure Returns a score between 0 and 1. """ # Simple implementation - could be enhanced with more sophisticated NLP words = _tokenize(text) if not words: return 0.0 # Average word length normalized to [0,1] range # Assumption: average English word is ~5 chars, so normalize around that avg_word_len = sum(len(word) for word in words) / len(words) word_len_score = min(avg_word_len / 10, 1.0) # Text length score - favor reasonable length responses ideal_length = 100 # words length_score = min(len(words) / ideal_length, 1.0) # Simple sentence structure check (periods, question marks, etc.) sentence_count = len(re.findall(r'[.!?]+', text)) + 1 sentence_ratio = min(sentence_count / (len(words) / 15), 1.0) # Combine scores fluency_score = (word_len_score + length_score + sentence_ratio) / 3 return fluency_score ``` **Format permintaan Lambda** Fungsi Lambda Anda menerima data dalam format ini: ``` [ { "id": "sample-001", "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Do you have a dedicated security team?" } ] }, { "role": "nova_assistant", "content": [ { "type": "text", "text": "As an AI developed by Company, I don't have a dedicated security team in the traditional sense. However, the development and deployment of AI systems like me involve extensive security measures, including data encryption, user privacy protection, and other safeguards to ensure safe and responsible use." } ] } ], "reference_answer": { "compliant": "No", "explanation": "As an AI developed by Company, I do not have a traditional security team. However, the deployment involves stringent safety measures, such as encryption and privacy safeguards." } } ] ``` **catatan** Struktur pesan mencakup `content` array bersarang, cocok dengan format data input. Pesan terakhir dengan peran `nova_assistant` berisi respons yang dihasilkan model. **Format respons Lambda** Fungsi Lambda Anda harus mengembalikan data dalam format ini: ``` [ { "id": "sample-001", "aggregate_reward_score": 0.75, "metrics_list": [ { "name": "accuracy", "value": 0.85, "type": "Metric" }, { "name": "fluency", "value": 0.90, "type": "Reward" } ] } ] ``` **Bidang respons**: + `id`: Harus cocok dengan ID sampel input + `aggregate_reward_score`: Skor keseluruhan (biasanya 0,0 hingga 1,0) + `metrics_list`: Array metrik individu dengan: + `name`: Pengidentifikasi metrik (misalnya, “akurasi”, “kelancaran”) + `value`: Skor metrik (biasanya 0,0 hingga 1,0) + `type`: Baik “Metrik” (untuk pelaporan) atau “Hadiah” (digunakan dalam pelatihan) ## Izin IAM **Izin yang diperlukan** Peran eksekusi SageMaker AI Anda harus memiliki izin untuk menjalankan fungsi Lambda Anda. Tambahkan kebijakan ini ke peran eksekusi SageMaker AI Anda: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": "arn:aws:lambda:region:account-id:function:function-name" } ] } ``` **Peran pelaksanaan Lambda** Peran eksekusi fungsi Lambda Anda memerlukan izin eksekusi Lambda dasar: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": "arn:aws:logs:*:*:*" } ] } ``` **Izin tambahan**: Jika fungsi Lambda Anda mengakses layanan AWS lain (misalnya, Amazon S3 untuk data referensi, DynamoDB untuk pencatatan), tambahkan izin tersebut ke peran eksekusi Lambda. ## Melaksanakan pekerjaan evaluasi 1. **Siapkan data Anda** + Format data evaluasi Anda sesuai dengan persyaratan format data + Unggah file JSONL Anda ke Amazon S3: `s3://your-bucket/eval-data/eval_data.jsonl` 1. **Konfigurasikan resep Anda** Perbarui resep sampel dengan konfigurasi Anda: + Setel `model_name_or_path` ke lokasi model Anda + Atur `lambda_arn` ke ARN fungsi reward Anda + Setel `output_s3_path` ke lokasi keluaran yang Anda inginkan + Sesuaikan `inference` parameter sesuai kebutuhan Simpan resepnya sebagai `rft_eval_recipe.yaml` 1. **Jalankan evaluasi** Jalankan pekerjaan evaluasi menggunakan notebook yang disediakan: [Notebook evaluasi model Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook) 1. **Pantau kemajuan** Pantau pekerjaan evaluasi Anda melalui: + SageMaker Konsol AI: Periksa status pekerjaan dan log + CloudWatch Log: Lihat log eksekusi terperinci + Lambda Logs: Masalah fungsi hadiah debug ## Memahami hasil evaluasi **Format output** Pekerjaan evaluasi menghasilkan hasil ke lokasi Amazon S3 yang Anda tentukan dalam format JSONL. Setiap baris berisi hasil evaluasi untuk satu sampel: ``` { "id": "sample-001", "aggregate_reward_score": 0.75, "metrics_list": [ { "name": "accuracy", "value": 0.85, "type": "Metric" }, { "name": "fluency", "value": 0.90, "type": "Reward" } ] } ``` **catatan** Output Pekerjaan Evaluasi RFT identik dengan format Respons Lambda. Layanan evaluasi melewati respons fungsi Lambda Anda tanpa modifikasi, memastikan konsistensi antara perhitungan hadiah Anda dan hasil akhir. **Menafsirkan hasil** **Skor Hadiah Agregat**: + Rentang: Biasanya 0,0 (terburuk) hingga 1,0 (terbaik), tetapi tergantung pada implementasi Anda + Tujuan: Angka tunggal yang merangkum kinerja keseluruhan + Penggunaan: Bandingkan model, lacak peningkatan selama pelatihan **Metrik Individu**: + Jenis Metrik: Metrik informasi untuk analisis + Jenis Hadiah: Metrik yang digunakan selama pelatihan RFT + Interpretasi: Nilai yang lebih tinggi umumnya menunjukkan kinerja yang lebih baik (kecuali jika Anda merancang metrik terbalik) **Tolok ukur kinerja** Apa yang dimaksud dengan kinerja “baik” tergantung pada kasus penggunaan Anda: | Rentang Skor | Interpretasi | Tindakan | | --- |--- |--- | | 0,8 - 1,0 | Sangat baik | Model siap untuk penyebaran | | 0,6 - 0,8 | Baik | Perbaikan kecil mungkin bermanfaat | | 0,4 - 0,6 | Adil | Diperlukan peningkatan yang signifikan | | 0,0 - 0,4 | Miskin | Tinjau data pelatihan dan fungsi hadiah | **penting** Ini adalah pedoman umum. Tentukan ambang batas Anda sendiri berdasarkan persyaratan bisnis, kinerja model dasar, kendala khusus domain, dan analisis biaya-manfaat pelatihan lebih lanjut.