Filtrare le funzioni richiamate
I filtri nel kernel semantico consentono agli sviluppatori di gestire e proteggere l'esecuzione delle funzioni abilitando controlli e visibilità con granularità fine. Sono fondamentali nella creazione di soluzioni di IA responsabili che soddisfano gli standard aziendali. I filtri convalidano azioni come le autorizzazioni utente o modificano le interazioni con i modelli di intelligenza artificiale per garantire la conformità e l'affidabilità.
Tipi di filtri
Il kernel semantico offre tre tipi di filtri per migliorare il controllo e la personalizzazione: filtri di invocazione di funzione per la gestione dell'esecuzione delle funzioni, filtri di rendering dei prompt per modificare i prompt prima dell'invio e filtri di invocazione automatica di funzione per indirizzare i flussi di lavoro in più passaggi. Ogni tipo di filtro soddisfa esigenze specifiche, consentendo agli sviluppatori di creare soluzioni di intelligenza artificiale sicure e adattabili.
Filtro invocazione di funzione
Questo filtro viene eseguito ogni volta che viene eseguita una funzione, indipendentemente dal fatto che provenga da un prompt o venga implementato in C#. Le sue funzionalità includono:
- Accesso ai metadati relativi alla funzione e ai relativi argomenti.
- Registrazione o convalida delle azioni prima e dopo l'esecuzione.
- Sovrascrittura dei risultati o ripetizione delle operazioni utilizzando modelli alternativi di intelligenza artificiale.
Di seguito è riportato un esempio di filtro di chiamata di funzione che registra la funzione plug-in richiamata:
public sealed class LoggingFilter(ILogger logger) : IFunctionInvocationFilter
{
public async Task OnFunctionInvocationAsync(FunctionInvocationContext context, Func<FunctionInvocationContext, Task> next)
{
logger.LogInformation("Invoking: {PluginName}.{FunctionName}", context.Function.PluginName, context.Function.Name);
await next(context);
logger.LogInformation("Executed: {PluginName}.{FunctionName}", context.Function.PluginName, context.Function.Name);
}
}
# Python example: Function invocation filter using a decorator
from semantic_kernel.functions.kernel_function_decorator import kernel_function
def logging_filter(func):
def wrapper(*args, **kwargs):
print(f"Invoking: {func.__qualname__}")
result = func(*args, **kwargs)
print(f"Executed: {func.__qualname__}")
return result
return wrapper
class WeatherForecastUtils:
@kernel_function(name="GetWeatherForCity", description="Gets the weather for a given city.")
@logging_filter
def get_weather_for_city(self, city: str) -> str:
return "Sunny"
Filtro di rendering delle richieste
Attivato durante il rendering della richiesta, questo filtro fornisce il controllo sulla formattazione e l'invio delle richieste all'intelligenza artificiale. È ideale per attività come la modifica di richieste di informazioni riservate (ad esempio, la redazione delle informazioni personali) o l'abilitazione della memorizzazione nella cache semantica.
Di seguito è riportato un esempio di filtro di rendering delle richieste:
public class SafePromptFilter : IPromptRenderFilter
{
public async Task OnPromptRenderAsync(PromptRenderContext context, Func<PromptRenderContext, Task> next)
{
await next(context);
// Modify prompt before submission
context.RenderedPrompt = "Safe and sanitized prompt.";
}
}
# Python example: Prompt render filter using a decorator
def safe_prompt_filter(render_func):
def wrapper(*args, **kwargs):
prompt = render_func(*args, **kwargs)
# Modify prompt before submission
return "Safe and sanitized prompt."
return wrapper
@safe_prompt_filter
def render_prompt(user_input):
return f"User prompt: {user_input}"
# Example usage
print(render_prompt("Sensitive information here"))
Filtro di invocazione automatica delle funzioni
Questo filtro viene richiamato solo durante il processo di chiamata automatica delle funzioni. Può regolare o persino terminare i flussi di lavoro in base ai risultati intermedi.
Di seguito è riportato un esempio di filtro di chiamata di funzione che termina il processo di invocazione della funzione.
public sealed class EarlyTerminationFilter : IAutoFunctionInvocationFilter
{
public async Task OnAutoFunctionInvocationAsync(AutoFunctionInvocationContext context, Func<AutoFunctionInvocationContext, Task> next)
{
await next(context);
var result = context.Result.GetValue<string>();
if (result == "desired result")
{
context.Terminate = true;
}
}
}
# Python example: Auto function invocation filter using a decorator
def early_termination_filter(func):
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
# Simulate checking the result and terminating if needed
if result == "desired result":
print("Terminating workflow early.")
return result
return result
return wrapper
@early_termination_filter
def auto_function():
# Simulate function logic
return "desired result"
# Example usage
auto_function()
Integrare i filtri delle funzioni
Per integrare uno dei filtri di funzione, è possibile usare i metodi seguenti:
- Iniezione di dipendenze:
Aggiungere la funzione ai servizi KernelBuilder:
builder.Services.AddSingleton<IFunctionInvocationFilter, LoggingFilter>();
- Proprietà del kernel:
Aggiungere la funzione all'elenco di FunctionInvocationFilters del kernel:
kernel.FunctionInvocationFilters.Add(new LoggingFilter(logger));
Per integrare i filtri in Python, applicare i decoratori ai metodi del plugin o alle funzioni di rendering, come illustrato in precedenza.
Registrare la classe del plug-in con il kernel come di consueto:
kernel.add_plugin(WeatherForecastUtils(), "WeatherForecastUtils")
I metodi decorati avranno la logica di filtro applicata automaticamente.
Richiamare sempre il delegato next nel filtro di funzione per consentire l'esecuzione dei filtri successivi o dell'operazione primaria. Ignorare questo passaggio blocca l'operazione.
Grazie all'integrazione dei filtri di rendering dei prompt, le soluzioni semantiche kernel sono più sicure e affidabili. I filtri prompt consentono di purificare le richieste prima di raggiungere l'intelligenza artificiale. I filtri di chiamata automatica consentono di controllare l'esecuzione della funzione, abilitando la terminazione anticipata o la logica personalizzata in base ai risultati.