Træn forklarlige boostmaskiner - regression

I denne artikel forklares det, hvordan du bruger EBM (Explainable Boost Machines) i Microsoft Fabric til at oplære regressionsmodeller. En EBM er en maskinel indlæringsteknik, der kombinerer styrken ved gradueringsforøgelse med fokus på modelfortolkning. En EBM skaber en blanding af beslutningstræer, lignende gradient boosting, men med et unikt fokus på at generere menneskelæselige modeller. EBMs giver både præcise forudsigelser og klare, intuitive forklaringer på disse forudsigelser. EBM'er er velegnede til programmer, der involverer sundhedspleje, økonomi og overholdelse af lovgivningen, hvor det er vigtigt at forstå de underliggende faktorer, der ligger til grund for modelbeslutninger.

I SynapseML kan du bruge en skalerbar implementering af forklarende styrkemaskiner – drevet af Apache Spark – til at oplære nye modeller. Denne vejledning beskriver, hvordan man bruger Apache Spark til at anvende skalerbarhed og fortolkbarhed af forklarbare boosting-maskiner i Microsoft Fabric.

Fordele ved forklarende styrkemaskiner

En EBM tilbyder en unik blanding af fortolknings- og forudsigelseskraft, hvilket gør den til et ideelt valg, når gennemsigtighed og forståelse af modeller til maskinel indlæring er afgørende. Med EBM'er kan brugerne opbygge værdifuld indsigt i de underliggende faktorer, der driver forudsigelser, og de kan derefter forstå, hvorfor en model træffer specifikke beslutninger eller forudsigelser. Dette er vigtigt for at opbygge tillid til AI-systemer.

Deres evne til at afdække komplekse sammenhænge i dataene, samtidig med at de leverer klare og fortolkelige resultater, gør EBM'er yderst nyttige inden for finans, sundhedspleje og svindelopdagelse. På disse områder er modelforklarlighed ikke kun nyttig, men ofte også et regulatorisk krav. I sidste ende kan en EBM balancere modellens ydeevne og gennemsigtighed og sikre nøjagtige, forståelige og ansvarlige AI-løsninger.

Forudsætninger

  • Brug Fabric Runtime 1.3 eller nyere til SynapseML EBM-understøttelse.
  • Vælg + og derefter Notesbog for at oprette en ny notesbog i dit arbejdsområde.

Bemærkning

I Fabric notesbøger er Spark-sessionen (spark) og funktionen display() tilgængelige som standard.

Opsæt MLflow

MLflow giver dig mulighed for at spore parametrene og resultaterne af modellen. Følgende kodestykke viser, hvordan du bruger MLflow til eksperimentering og sporing. Værdien ebm-wine-recognition-regression er navnet på det eksperiment, der logfører oplysningerne.

# Import MLflow
import mlflow

# Create a new experiment for the EBM regression example.
mlflow.set_experiment("ebm-wine-recognition-regression")

Kør følgende kode for at verificere, at eksperimentet blev oprettet:

experiment = mlflow.get_experiment_by_name("ebm-wine-recognition-regression")
assert experiment is not None, "Experiment creation failed"
print(f"Experiment '{experiment.name}' created with ID: {experiment.experiment_id}")

Indlæs data

Følgende kodeuddrag indlæser og forbereder det standard Wine Recognition-datasæt fra scikit-learn. Datasættet indeholder 178 prøver med 13 numeriske egenskaber, der beskriver vinens kemiske egenskaber. Selvom datasættet var designet til klassificering, bruger dette eksempel de numeriske målværdier til at demonstrere en EBM-regressionsarbejdsgang. Koden konverterer Pandas-dataframe, som returneres af scikit-learn, til en Spark-dataframe, som Spark ML-stil trænere kræver:

import sklearn

# Load the Wine Recognition dataset using the as_frame argument for Pandas compatibility.
bunch = sklearn.datasets.load_wine(as_frame=True)

# Extract the data into a Pandas dataframe.
pandas_df = bunch['data'].copy()

# Add the target variable to the Pandas dataframe.
pandas_df['target'] = bunch['target']

# Convert the Pandas dataframe to a Spark dataframe.
df = spark.createDataFrame(pandas_df)

# Display the resulting Spark dataframe.
display(df)

Kør følgende kode for at verificere, at datarammen har den forventede form:

row_count = df.count()
col_count = len(df.columns)
assert row_count == 178, f"Expected 178 rows, got {row_count}"
assert col_count == 14, f"Expected 14 columns, got {col_count}"
print(f"Dataset loaded: {row_count} rows, {col_count} columns")

Forbered data

For elever i Spark ML-stil er det vigtigt at organisere funktionerne i en kolonne med vektorværdier. I dette eksempel hedder kolonnen features. Denne kolonne inkluderer alle kolonner fra den indlæste dataframe, undtagen målvariablen. Dette kodeuddrag viser, hvordan man bruger VectorAssembler ressourcen til korrekt at strukturere funktionerne til efterfølgende Spark ML-baseret modellering:

from pyspark.ml.feature import VectorAssembler

# Define the name of the target variable column.
labelColumnName = 'target'

# Create a VectorAssembler to consolidate features.
assembler = VectorAssembler(outputCol='features')

# Specify the input columns, excluding the target column.
assembler.setInputCols([c for c in df.columns if c != labelColumnName])

# Transform the dataframe to include the 'features' column.
df_with_features = assembler.transform(df)

Kør følgende kode for at verificere, at features-kolonnen er oprettet med den korrekte længde:

first_row = df_with_features.select("features").first()
feature_length = len(first_row['features'])
assert feature_length == 13, f"Expected 13 features, got {feature_length}"
print(f"Feature vector created with {feature_length} elements")

Oplær modellen

Følgende kodestykke bruger Synapse ML-biblioteket til at starte processen til oprettelse af EBM-regressionsmodel. Den initialiserer først EBM-regressionsestimatet og angiver, at en regressionsopgave skal bruge den. Derefter angives navnet på navnekolonnen for at sikre, at modellen ved, hvilken kolonne der skal forudsiges. Endelig passer modellen til det forbehandlede datasæt:

# Import the EBMRegression estimator from Synapse ML.
from synapse.ml.ebm import EbmRegression

# Create an instance of the EBMRegression estimator.
estimator = EbmRegression()

# Set the label column for the regression task.
estimator.setLabelCol(labelColumnName)

# Fit the EBM regression model to the prepared dataset.
model = estimator.fit(df_with_features)

Kør følgende kode for at verificere, at modellen kan generere forudsigelser:

predictions = model.transform(df_with_features)
pred_count = predictions.count()
assert pred_count == 178, f"Expected 178 predictions, got {pred_count}"
assert "prediction" in predictions.columns, "Prediction column missing"
print(f"Model trained. Predictions generated for {pred_count} rows.")

Log kør metadata med MLflow:

with mlflow.start_run():
    mlflow.log_param("model_type", "EbmRegression")
    mlflow.log_param("label_column", labelColumnName)
    mlflow.log_param("num_features", 13)
    mlflow.log_metric("training_rows", pred_count)

Få vist globale forklaringer

Du kan hente visualiseringsombrydningen interpret og bruge bibliotekets show metode til at visualisere den overordnede forklaring af modellen. Visualiseringsombrydning fungerer som en bro for at lette modellens visualiseringsoplevelse. Følgende kodestykke viser, hvordan du gør det:

# Get the visualization wrapper for the model.
wrap = model.getVizWrapper()

# Generate the global explanation.
explanation = wrap.explain_global()

Kør følgende kode for at verificere, at forklaringsobjektet er genereret:

assert explanation is not None, "Global explanation generation failed"
print(f"Global explanation generated with data for {len(explanation.data()['names'])} features")

Importér derefter interpret biblioteket, og brug show metoden til at få vist forklaringen:

import interpret
interpret.show(explanation)

Begrebet "vigtigheder" vist på det følgende billede repræsenterer det gennemsnitlige absolutte bidrag (score) af hvert begreb (egenskab eller interaktion) til forudsigelser. Disse bidrag beregnes i gennemsnit på tværs af oplæringsdatasættet for at tage højde for antallet af eksempler i hver beholder og prøvevægtene (hvis det er relevant). Forklaringen viser de øverste 15 vigtigste ord.

Skærmbillede af globale forklaringer, der viser vigtigheden af funktioner for EBM-regressionsmodellen.

Få vist lokale forklaringer

De angivne forklaringer fungerer på globalt plan, men i nogle scenarier er output pr. funktion også værdifulde. Både træneren og modellen giver mulighed for at angive kolonnen, som introducerer en anden kolonne med vektorværdier, når den featureScoresCol udfyldes. Hver vektor i denne kolonne svarer til længden af funktionskolonnen, og hver værdi svarer til funktionen i det samme indeks. Disse værdier repræsenterer hver funktionsværdis bidrag til modellens endelige output.

I modsætning til globale forklaringer er der i øjeblikket ingen direkte integration med den interpret visualisering for output pr. funktion. Det skyldes, at globale visualiseringer primært skaleres med antallet af funktioner (en typisk lille værdi), mens lokale forklaringer skaleres med rækkeantallet (hvilket for en Spark-dataramme kan være betydeligt).

Følgende kodestykke viser, hvordan du konfigurerer og bruger kolonnen featureScoresCol :

# Set the featureScoresCol to include per-feature outputs.
prediction = model.setFeatureScoresCol("featurescores").transform(df_with_features)

# For small datasets, you can collect the results to a single machine without issues.
# For larger datasets, use caution when collecting all rows locally.
# In this example, convert to Pandas for easy local inspection.
predictions_pandas = prediction.toPandas()
predictions_list = prediction.collect()

Udskriv de første eksempeloplysninger:

# Extract the first example from the collected predictions.
first = predictions_list[0]

# Print the lengths of the features and feature scores.
print('Length of the features is', len(first['features']), 'while the feature scores have length', len(first['featurescores']))

# Print the values of the features and feature scores.
print('Features are', first['features'])
print('Feature scores are', first['featurescores'])

Kør følgende kode for at verificere, at feature-scorerne har den forventede form:

assert len(first['features']) == len(first['featurescores']), "Feature and score lengths don't match"
assert len(first['featurescores']) == 13, f"Expected 13 scores, got {len(first['featurescores'])}"
print(f"Feature scores verified: {len(first['featurescores'])} scores for {len(first['features'])} features")

Kodeuddraget viste, hvordan man tilgår og udskriver feature- og tilsvarende featurescores for det første eksempel i forudsigelserne. Denne kode producerer følgende output:

Length of the features is 13 while the feature scores have length 13
Features are [14.23, 1.71, 2.43, 15.6, 127.0, 2.8, 3.06, 0.28, 2.29, 5.64, 1.04, 3.92, 1065.0]
Feature scores are [-0.05929027436479602,-0.06788488062509922,-0.0385850430666259,-0.2761907140329337,-0.0423377816119861,0.03582834632321236,0.07759833436021146,-0.08428610897153033,-0.01322508472067107,-0.05477604157900576,0.08087667928468423,0.09010794901713073,-0.09521961842295387]

Troubleshooting

Problem Årsag Opløsning
ModuleNotFoundError: No module named 'synapse.ml.ebm' Notebooken bruger ikke en Fabric-runtime, der understøtter EBM. Brug Fabric Runtime 1.3 eller senere i workspace Spark-indstillingerne.
interpret.show() Viser intet output Notesbogen gengiver ikke den inline visualisering. Brug explanation.data() den til at inspicere forklaringsdataene direkte.
Out-of-memory-fejl under prediction.collect() Datasættet er for stort til at indsamle til føreren. Brug prediction.limit(100).toPandas() til lokal inspektion i stedet for at samle alle rækker.
AnalysisExceptionfor kolonnen features Forvandlingen VectorAssembler blev sprunget over eller mislykkedes. Kør Prepare datacellen igen og bekræft, at den df_with_features indeholder kolonnen features .

Relateret indhold

  • Last updated on