Dans Weave, les attributs vous permettent d’associer des métadonnées personnalisées à vos traces et évaluations. Ces métadonnées peuvent inclure des informations comme des noms d’environnement, des versions de modèle, des ID d’expérience, des ID d’utilisateur ou d’autres informations contextuelles pour vous aider à organiser, filtrer et analyser vos données Weave.
Les attributs sont particulièrement utiles lorsque vous devez regrouper ou filtrer les traces en fonction des éléments suivants :
- Déploiements
- tenants
- Experiments
Weave propose deux façons d’ajouter des attributs :
- Attributs par appel : utilisez
weave.attributes() pour ajouter des métadonnées à des opérations spécifiques ou à des blocs de code
- Attributs globaux : utilisez le champ
global_attributes pour définir des attributs lors de l’initialisation, qui s’appliquent à toutes les traces et évaluations de votre projet
Vous pouvez afficher tous les attributs enregistrés au cours des traces et des évaluations dans l’UI. Vous pouvez ensuite les utiliser pour filtrer et regrouper les données.
call.attributes ne peut pas être modifié une fois l’appel commencé. Utilisez ce
gestionnaire de contexte pour définir les métadonnées avant d’invoquer l’op.
weave.attributes() vous permet d’ajouter des métadonnées à des opérations tracées spécifiques. Vous pouvez ainsi associer des informations contextuelles à certains appels de fonction ou runs d’évaluation.
import weave
weave.init("<your-team-name/your-project-name>")
@weave.op
def my_function(name: str):
return f"Hello, {name}!"
# Ajouter des attributs à un appel spécifique
with weave.attributes({'env': 'production', 'user_id': '12345'}):
result = my_function("World")
import {init, op, withAttributes} from 'weave';
async function main() {
await init('your-team/attribute-example');
const myFunction = op(async function myFunction(name: string) {
return `Hello, ${name}!`;
});
// Ajouter des attributs à un appel spécifique
const result = await withAttributes(
{env: 'production', user_id: '12345'},
async () => myFunction('World')
);
console.log('Result:', result);
}
main().catch(console.error);
weave.attributes(). Les contextes internes remplacent les contextes externes pour les mêmes clés :
@weave.op
def process_data(data: str):
return data.upper()
# Contexte externe
with weave.attributes({
"env": "production",
"version": "1.0.0",
"region": "us-west-2"
}):
process_data("hello") # Inclut les trois attributs
# Le contexte interne remplace 'version'
with weave.attributes({
"version": "1.1.0",
"experiment": "exp-456"
}):
process_data("world") # Inclut env='production', version='1.1.0', region='us-west-2', experiment='exp-456'
import {init, op, withAttributes} from 'weave';
async function main() {
await init('your-team/attribute-example');
const processData = op(async function processData(data: string) {
return data.toUpperCase();
});
// Contexte externe
await withAttributes(
{
env: 'production',
version: '1.0.0',
region: 'us-west-2'
},
async () => {
await processData('hello'); // Inclut les trois attributs
// Le contexte interne remplace 'version'
await withAttributes(
{
version: '1.1.0',
experiment: 'exp-456'
},
async () => {
await processData('world'); // Inclut env='production', version='1.1.0', region='us-west-2', experiment='exp-456'
}
);
}
);
}
main().catch(console.error);
import weave
weave.init(
"my-project",
global_attributes={
"env": "production",
"app_version": "2.1.0",
"region": "us-west-2",
"team": "ml-platform"
}
)
# Le dictionnaire global_attributes applique désormais ces attributs à toutes les opérations suivantes
@weave.op
def my_function():
return "Hello"
my_function() # Hérite automatiquement de tous les attributs globaux
# Les évaluations héritent également des attributs globaux
evaluation = weave.Evaluation(dataset=examples, scorers=[scorer])
asyncio.run(evaluation.evaluate(model)) # Hérite de tous les attributs globaux
import {init, op, withAttributes} from 'weave';
async function main() {
await init('your-team/attribute-example', {
globalAttributes: {
env: 'production',
app_version: '2.1.0',
region: 'us-west-2',
team: 'ml-platform'
}
});
// L'objet globalAttributes applique désormais ces attributs à toutes les opérations suivantes
const myFunction = op(async function myFunction() {
return 'Hello';
});
const result = await myFunction(); // Hérite automatiquement de tous les attributs globaux
console.log('Result:', result);
}
main().catch(console.error);
Combiner les attributs globaux et les attributs par appel
import weave
# Définir les attributs globaux
weave.init(
"my-project",
global_attributes={
"env": "production",
"app_version": "2.1.0"
}
)
@weave.op
def process(data: str):
return data
# Cet appel utilise : env='production', app_version='2.1.0'
process("test1")
# Cet appel utilise : env='staging', app_version='2.1.0', experiment='A'
with weave.attributes({'env': 'staging', 'experiment': 'A'}):
process("test2")
import {init, op, withAttributes} from 'weave';
async function main() {
// Définir les attributs globaux
await init('your-team/attribute-example', {
globalAttributes: {
env: 'production',
app_version: '2.1.0'
}
});
const process = op(async function process(data: string) {
return data;
});
// Cet appel utilise : env='production', app_version='2.1.0'
await process('test1');
// Cet appel utilise : env='staging', app_version='2.1.0', experiment='A'
await withAttributes(
{env: 'staging', experiment: 'A'},
async () => process('test2')
);
}
main().catch(console.error);
Obtenir des attributs pendant l’exécution
L’exemple suivant utilise le décorateur Weave pour enregistrer la fonction process_data, configure les attributs à enregistrer, puis les renvoie à l’exécution.import weave
weave.init("your-team/your-project")
@weave.op
def process_data(data: str):
# Obtenir l'appel courant à l'intérieur de l'op
call = weave.get_current_call()
if call:
print(f"Attributes: {call.attributes}")
return data.upper()
# Définir des attributs et exécuter la fonction
with weave.attributes({
"env": "production",
"version": "1.0.0",
"region": "us-west-2"
}):
process_data("hello")
with weave.attributes({
"version": "1.1.0",
"experiment": "exp-456"
}):
process_data("world")
Attributes: {'env': 'production', 'version': '1.0.0', 'region': 'us-west-2'}
Attributes: {'env': 'production', 'version': '1.1.0', 'region': 'us-west-2', 'experiment': 'exp-456'}
weave.get_current_call() fonctionne uniquement à l’intérieur d’une fonction décorée avec @weave.op. En dehors d’un op, il renvoie None.
Avec le SDK TypeScript de Weave, vous pouvez obtenir les attributs actuels avec client.getCurrentAttributes(). Contrairement au SDK Python de Weave, vous pouvez accéder aux attributs TypeScript dans un contexte withAttributes(), et pas uniquement à l’intérieur d’un op.import * as weave from 'weave';
import { withAttributes } from 'weave';
async function main() {
const client = await weave.init('your-team/your-project');
const processData = weave.op(async function processData(data: string) {
// Vous pouvez aussi accéder aux attributs à l'intérieur d'un op
const attrs = client.getCurrentAttributes();
console.log('Attributes inside op:', attrs);
return data.toUpperCase();
});
// Définir des attributs et exécuter la fonction
await withAttributes(
{
env: 'production',
version: '1.0.0',
region: 'us-west-2'
},
async () => {
// Obtenir les attributs depuis n'importe quel endroit du contexte
console.log('Current attributes:', client.getCurrentAttributes());
await processData('hello');
await withAttributes(
{
version: '1.1.0',
experiment: 'exp-456'
},
async () => {
console.log('Nested attributes:', client.getCurrentAttributes());
await processData('world');
}
);
}
);
}
main().catch(console.error);
Current attributes: { env: 'production', version: '1.0.0', region: 'us-west-2' }
Attributes inside op: { env: 'production', version: '1.0.0', region: 'us-west-2' }
Nested attributes: { env: 'production', version: '1.1.0', region: 'us-west-2', experiment: 'exp-456' }
Attributes inside op: { env: 'production', version: '1.1.0', region: 'us-west-2', experiment: 'exp-456' }
