Evaluation Primitives | LangSmith Evaluations - Part 2

Summary

この動画スクリプトでは、Lang Smith評価システムの基本的な要素について説明されています。スクリプトでは、データセットの作成、評価器の実装、評価の適用、タスクの指定など、評価プロセスを構築するための4つのカテゴリーについて話し及んでいます。また、ラン、トレース、プロジェクトといった概念も紹介されており、情報フローがどのように評価に役使われるかが詳細に説明されています。この概要は、ユーザーを引き込み、興味を引き出すように、スクリプトの要点を簡潔かつ正確に提供しています。

Takeaways

• 📝 ランスミス評価についての第2回目の動画を開始します。
• 🌟 基本的なコンポーネント、またはランスミスを理解するための基本的な要素について説明します。
• 🏞️ データセットの構築、評価器の実装、評価の適用、タスクの指定など、4つのカテゴリーについて議論した先のものです。
• 📈 データセットは、手動でキュレーションされたもの、ログからのもの、または合成されたものなど、様々な種類がありますが、基本的にはシンプルで、入力とオプションの出力を持っています。
• 🔄 各ステップの単一作業単位を「ラン」と呼び、例えば、Q&Aアプリでは、質問から文書へのランと文書から回答へのランの2つがあります。
• 📊 ランはタグ付けされ、フィードバックが与えられ、メタデータが追加されます。ランは「トレース」にまとめられ、トレースはランのコレクションです。
• 🎯 プロジェクトは、特定のアプリケーションに関連するトレースの集合です。例えば、Q&Aアプリが実際に使用されている場合、すべてのトレースはそのプロジェクトに記録されます。
• 👨‍🏫 評価器には様々な種類があり、LM（言語モデル）評価器、ヒューリスティック評価器、人間評価者などがあります。
• 🔧 評価器は、比較モードや参照なしモードなど、異なるモードで使用できます。
• 🚀 評価が実行される際の情報フローについて説明します。データセットの各例には、入力と出力が含まれており、アプリケーションに入力を渡すと、そのアプリケーションからの出力が得られます。
• 📊 評価器は、LMの出力を評価し、スコアを出力します。これは評価プロセスの主要な要素です。

Q & A

ランスミス評価とは何ですか？

ランスミス評価は、自然言語処理アプリケーションの性能を評価するための框架です。データセットの構築、評価器の実装、評価の適用、タスクの指定という4つのカテゴリーに分けられます。

SLE units と runs の違いは何ですか？

SLE unitsは、ランスミス評価において、処理の最小単位です。一方、runsは、タスクの実行において、処理を表す単位です。例えば、質問から文書へのインデックス作成と、文書から回答への生成に基づく場合、2つのrunsが存在します。

トレースとは何ですか？

トレースは、ランスミス評価において、複数のrunsの集合を指します。たとえば、RAG（Retrieval-Augmented Generation）アプリケーションにおいて、検索ステップのRunと生成ステップのRunが含まれます。

プロジェクトはどのように定義されますか？

プロジェクトは、特定のアプリケーションに関連する複数のトレースの集合です。たとえば、RAGアプリケーションが実際に使用されている場合、すべてのユーザーが使用したトレースがそのプロジェクトに記録されます。

データセットの役割は何ですか？

データセットは、ランスミス評価において、入力とオプションの出力を持つシンプルなデータ構造です。例えば、RAGアプリケーションでは、質問と回答のペアが含まれるデータセットを作成することがあります。

データセットの例として挙げられたものにはどのような種類がありますか？

データセットには、手動でキュレートされたもの、ログから生成されたもの、または合成されたものがあります。データセットは、入力とオプションの出力を持つ複数の例の集合です。

評価器の種類にはどのようなものがありますか？

評価器には、LM（Language Model）評価器、ヒューリティック評価器、人間評価器などがあります。また、比較モードや、参照なしモードなど、評価の方法も異なります。

評価が実行される際の情報フローを説明してください。

評価の際、データセットの各例の入力と出力が評価対象のアプリケーションに入力されます。アプリケーションからの出力と、データセットにおける真実の出力が評価器に渡され、評価器はそれらを比較してスコアを出力します。

RAGアプリケーションにおいて、どの2つのステップが含まれていますか？

RAGアプリケーションには、検索ステップと生成ステップの2つのステップが含まれます。検索ステップでは文書が検索され、生成ステップでは文書に基づく回答が生成されます。

評価器がどのように動作するか説明してください。

評価器は、アプリケーションからの出力とデータセットにおける真実の出力を比較し、その結果を基にスコアを割り当てます。このプロセスは、評価器が与えられた基準に基づいて、両方の出力を「判断」することによって行われます。

次回の動画ではどのような内容が含まれる予定ですか？

次回の動画では、より詳細な情報、コード例などが提供される予定です。これにより、ランスミス評価の核心となる概念について深く理解することができるでしょう。

Outlines

00:00

📚 Lang Smithの基本

Lanceは、Lang Smith評価のセカンドビデオを紹介し、基本的な構成要素について説明しています。このビデオでは、データセットの構築、評価者の実装、評価の適用、そして関心のあるタスクの特定に焦点を当てています。具体的には、質問応答（Q&A）タスクにおいて、質問からドキュメントを検索し、そのドキュメントを基に回答を生成するプロセスを例として挙げています。このプロセスは、検索と生成の二つのステップから成り立ち、各ステップは「ラン」と呼ばれる作業単位によって定義されます。ランはタグ付けが可能であり、フィードバックやメタデータを含むことができます。複数のランは「トレース」として集約され、プロジェクトは特定のアプリケーションに関連するトレースのコレクションとして定義されます。データセットは入力と任意の出力を持ち、簡単なキーバリューペアで構成されることが多いです。評価者は、LMやヒューリスティックな評価、人間の判断など、さまざまな種類の評価者を選択することができ、評価プロセスでは入力とその生成された出力が評価者によって評価されます。

05:01

🔍 評価プロセスの概要

このパートでは、Lang Smithの評価器を利用した評価プロセスについて説明しています。具体的には、アプリケーションがデータセットから入力を受け取り、出力を生成し、その出力とデータセット内の正解（グラウンドトゥルース）とを評価器が比較するプロセスに焦点を当てています。評価器はラベル中心のアプローチを用いてアプリケーションの出力と正解とを比較し、スコアを出力します。このビデオでは、評価プロセスを通じて情報がどのように流れるか、また評価における主要なステップを理解することが重要であり、これが理解できれば、Lang Smithの評価システムをより深く理解するための基盤となると述べています。最後に、次のビデオでさらに詳細な説明とコード例を提供することを予告しています。

Keywords

💡Lang Smith evaluation

「Lang Smith evaluation」は、このビデオの主題であり、人工知能（AI）における言語処理の評価方法を指します。この手法は、データセットの構築、評価器の実装、評価の適用、タスクの指定など、複雑なプロセスを構築し、最適な結果を得るために使用されます。

💡Primitives

「Primitives」とは、基本的な構成要素を意味し、このビデオではLang Smith評価における核心的な概念を指しています。これらの基本概念を理解することで、より複雑な評価プロセスを構築することができます。

💡Runs

「Runs」とは、Lang Smith評価において、処理の単位を指します。各ステップは一つの「run」として扱われ、例えば質問から文書へのインデックス作成や、文書から回答への生成などが含まれます。

💡Traces

「Traces」は、一連の「runs」を集めたものです。特定のアプリケーションにおいて、一連の処理が行われた後にログに記録されるものです。例えば、RAG（Retrieval-Augmented Generation）アプリケーションにおいて、検索ステップと生成ステップの二つの「runs」が「traces」に記録されます。

💡Projects

「Projects」は、与えられたアプリケーションに対して複数の「traces」を集めたものです。これは、アプリケーションが実際に使用される際に、ユーザーが使用したすべての「traces」をログに記録し、プロジェクトに蓄積することを意味します。

💡Data sets

「Data sets」は、評価プロセスにおいて使用されるデータの集合体であり、入力とオプションの出力から成り立っています。これらのデータセットは、AIアプリケーションの性能を評価するために使用され、例として質問と回答のペアが含まれることがあります。

💡Evaluators

「Evaluators」は、AIアプリケーションの出力と期待される出力（真実）の比較を行って評価を行うものであり、様々な種類があります。これには、LM（Language Model）評論家、手法的評論家、人間評論家などが含まれます。

💡Information flow

「Information flow」とは、評価プロセスにおいて情報がどのように流れるかを示すものです。データセットから出力された入力がアプリケーションに渡され、アプリケーションからの出力とデータセットの真実が出力されます。評価器は、これらの出力を比較して最終的なスコアを出すプロセスです。

💡RAG (Retrieval-Augmented Generation)

「RAG」は、検索を強化した生成と呼ばれるAIアプリケーションの手法であり、文書の検索と生成された回答の作成を組み合わせたものです。このプロセスは、質問に対する回答を生成するために使用されます。

💡LM (Language Model)

「LM」は、言語モデルの略で、自然言語処理において文書の意味や文法を分析するAIモデルを指します。このモデルは、テキストの予測や生成など、様々なタスクに適用されており、評価プロセスにおいても重要な役割を果たします。

💡Ground truth

「Ground truth」とは、データセットにおいて正解や真実の基準を指すものです。AIアプリケーションの出力と比較して、どの程度正確かを評価するために使用されます。

Highlights

Introduction to Lang Smith evaluation in the context of LM applications.

Exploration of the core primitives or basic components of Lang Smith for understanding its functionality.

Discussion on landscape evaluations focusing on four categories: building datasets, implementing evaluators, applying evals, and specifying tasks.

Explanation of the Retrieve-and-Generate (RAG) app as a popular use case in LM applications.

Definition of 'run' as the single unit of work for each step in the RAG process, distinguishing between indexing/retrieval and generation.

Description of how runs are tagged, can have feedback, and contain metadata.

Aggregation of runs into traces, which are collections of runs, and how traces are logged into projects.

Clarification on the simplicity of datasets, consisting of inputs and optionally outputs, with examples like question-answer pairs.

Mention of different types of datasets, including those that require specific formats for fine-tuning.

Overview of evaluators, including LM, heuristic, and human judges, and different modes like comparison and reference-free evaluation.

Explanation of the information flow during an evaluation, where the evaluator compares the app's output to the ground truth.

Use of built-in evaluators for grading, especially those designed for comparison between LM outputs and ground truth.

The process of how an input is processed by the app to produce an output, which is then evaluated against the ground truth.

The role of the judge in making a decision based on the comparison of outputs, resulting in a score.

The importance of understanding the core primitives for grasping the bigger picture of Lang Smith evaluations.

预告：下个视频中将提供更多细节和代码示例。

Transcripts

hi this is Lance lanching this is our

second video on Lang Smith evaluation

I'm going to walk through kind the core

Primitives or the basic components of

lsmith to give you a sense of how to

kind of build up your understanding from

scratch so in the pirate video we talked

about kind of landscape evaluations and

the things you a want to do in terms of

these four categories building data sets

implementing evaluators um and then

applying evals and of course specifying

a task you care about so let's let's

actually kind of build this up let's say

have an LM app like have a task and rag

is a very popular use case there is an

index you do retrieval and then you do

generation based on this the retrieve

documents to produce an answer so it's

question in answer out now the single

unit of work for each of these steps we

call a run so in this particular case

there's two runs here one is question to

documents and then documents to answer

so it's indexing or retrieval and

generation those are the two core steps

so to speak SLE units will work runs can

be tagged they can you can have feedback

to runs you can have metadata to runs

which we're going to talk about later

now runs are rolled up into traces so

traces just collection of runs um and

for example in this particular case the

rag app Trace would have the two runs

the Run for the retrieval step the Run

for the generation step that's kind of

it and then a project is just a

collection of traces for given app so

let's say I had this rag app it was in

production somewhere a bunch of users

used basically used it um that all those

traces would this be logged to that

particular project so that's really it

so kind of again I have an app it's a

rag app it has two steps each step is a

run the app going from you know input to

Output is a trace that Trace contains

the two runs and every time I run that

app all those traces get rolled into

into a project that's kind of it so

those are the kind key key components of

like of kind of the task component or

the app component of this four you know

these four pieces that we've been

talking about now data sets here we kind

of talked about the flavors of data set

you might want manually curated from

logs or synthetic but really at the core

data sets are pretty simple they just

have an input and optionally an output

um so in the case like if you're doing a

rag app you might have a data set with

question answer pairs in that case there

is an input and an output each of the

pairs typically doesn't have to be is

just like a for example a dict or a key

value pair like question um your

question answer your answer um now

that's an example and the data set is

just a collection of examples and as I

just mentioned a lot of times the input

outputs are just like key values you

know so in the case of rag question

answer you know key value pairs for my

input and my output um there are other

types of data sets that are interesting

though chat and Ln in particular these

are a little bit more relevant if you

kind of want to do things like

fine-tuning in which the data set

requires a particular format like for

for example chatter Ln format for a lot

of applications we'll talk about key

value is is completely fine and again

your data set composed of examples each

example just has an input and optionally

an output that's really

um and now evaluator so what's happening

here we we kind of talk through a few

different flavors here there's different

kinds of Judges you can chw so like LM

as a judge heuristic judges like

function the human judge and then

different modes like comparison

comparing two different traces for

example two different Generations um

reference free so like there's no ground

truth you give an llm judge a bunch of

General criteria um or if Human been

judge General criteria and then of

course you can also provide ground truth

so are kind of like the things you can

think about in terms of

evaluation now here's a very important

piece where these all come together so

like what's the information flow when

you run an evaluation what's the evalu

really doing so again our data sets

composed of examples each example is an

input and an output when you run an

evaluation you take that input and you

Plum it into your application so let's

thing about a rag app for example the

input's a question we Plum that into our

rag chain we get some output answer

that's that that's what you see on that

bottom uh kind of in red now also you

have your ground truth answer as an

output in your data set that also gets

plunged through to the evaluator so the

evaluator which is kind of very

intuitive has access to a grou answer in

the case of this rag toy example and the

Ln answer your rag chain answer and then

it's doing some judging at the two now

this is where there's a lot of different

interesting options here you can build a

custom evaluator like we talked about

you can also use a bunch of

off-the-shelf lsmith evaluators to do

the grading so in this particular case

we have an answer from you know our LM

we have a ground truth answer and we

want to use a built-in evaluator we can

use one of the evaluators that are label

Centric so they are like tuned or or

designed to do uh comparison between

like an Ln output and a groud truth

output and we'll talk about the various

options later but I just want to give

you a flavor of really what's happening

here is you have your data set of

examples you're passing the you know the

expected in this particular case example

to your judge um you have your app which

is receiving input from your data set

it's producing its own output so now you

have an output from your app you have

the ground truth output you pass them to

a judge a judge make a decision and

outputs effectively a some kind of score

that's really it that's the big picture

for how to think about the information

flow when doing

evaluations and that's really it you

know for like the core Primitives this

is the key thing to understand and once

you understand this everything else is

kind of is pretty easy um so we're going

to be talking about a little bit more

detail and and show some code examples

in the next video thank

you