Del via

Eksempel på kunstig intelligens med AdventureWorks-datasettet (forhåndsversjon)

  • Artikkel

Denne artikkelen beskriver hvordan du konfigurerer en ai-ferdighet ved hjelp av et lakehouse som datakilde. For å illustrere prosessen oppretter vi først et lakehouse, og deretter legger vi til data i den. Deretter oppretter vi en AI-ferdighet og konfigurerer lakehouse som datakilde. Hvis du allerede har en Semantisk Power BI-modell (med de nødvendige lese-/skrivetillatelsene), et lager eller en KQL-database, kan du følge de samme trinnene etter at du har opprettet AI-kompetansen for å legge til datakildene. Mens trinnene som vises her fokuserer på lakehouse, er prosessen lik for andre datakilder – du trenger bare å gjøre justeringer basert på det bestemte valget.

Viktig

Denne funksjonen er i forhåndsvisning.

Forutsetning

Opprett et lakehouse med AdventureWorksLH

Først oppretter du et lakehouse og fyller det ut med de nødvendige dataene.

Hvis du allerede har en forekomst av AdventureWorksLH i et lakehouse (eller et lager), kan du hoppe over dette trinnet. Hvis ikke, kan du bruke følgende instruksjoner fra en Fabric-notatblokk til å fylle ut lakehouse med dataene.

  1. Opprett en ny notatblokk i arbeidsområdet der du vil opprette ai-ferdighetene dine.

  2. Velg + Datakilder til venstre i Explorer-ruten. Med dette alternativet kan du legge til et eksisterende lakehouse eller opprette et nytt lakehouse. For klarhet, opprett et nytt innsjøhus og tilordne et navn til det.

  3. Legg til følgende kodesnutt i den øverste cellen:

    import pandas as pd
from tqdm.auto import tqdm
base = "https://synapseaisolutionsa.blob.core.windows.net/public/AdventureWorks"

# load list of tables
df_tables = pd.read_csv(f"{base}/adventureworks.csv", names=["table"])

for table in (pbar := tqdm(df_tables['table'].values)):
    pbar.set_description(f"Uploading {table} to lakehouse")

    # download
    df = pd.read_parquet(f"{base}/{table}.parquet")

    # save as lakehouse table
    spark.createDataFrame(df).write.mode('overwrite').saveAsTable(table)

  4. Velg Kjør alle.

    Skjermbilde som viser en notatblokk med opplastingskoden AdventureWorks.

Etter noen minutter fylles lakehouse med de nødvendige dataene.

Opprett en AI-ferdighet

Hvis du vil opprette en ny ai-ferdighet, går du til arbeidsområdet og velger + Nytt element-knappen, som vist i dette skjermbildet:

Skjermbilde som viser hvor du kan opprette kunstig intelligens-ferdigheter.

Søk etter ai-kompetanse for å finne det riktige alternativet i kategorien Alle elementer. Når dette er valgt, ber en ledetekst deg om å oppgi et navn for ai-ferdigheten din, som vist i dette skjermbildet:

Skjermbilde som viser hvor du kan angi navn for ai-ferdigheter.

Når du har skrevet inn navnet, fortsetter du med følgende trinn for å justere ai-ferdigheten med dine spesifikke krav.

Velg dataene

Velg lakehouse du opprettet i forrige trinn, og velg deretter Legg til. Når lakehouse er lagt til som en datakilde, viser Explorer-ruten på venstre side av AI-ferdighetssiden navnet på lakehouse. Velg lakehouse for å vise alle tilgjengelige tabeller. Bruk avmerkingsboksene til å velge tabellene du vil gjøre tilgjengelig for kunstig intelligens. Velg disse tabellene for dette scenarioet:

  • dimcustomer
  • dimdate
  • dimgeography
  • dimproduct
  • dimproductcategory
  • dimpromotion
  • dimreseller
  • dimsalesterritory
  • factinternetsales
  • cactresellersales

Skjermbilde som viser hvor du kan velge tabeller for kunstig intelligens.

Gi instruksjoner

Hvis du vil legge til ai-instruksjoner, velger du AI-instruksjoner-knappen for å åpne ai-instruksjonerruten til høyre. Du kan legge til følgende instruksjoner.

Datakilden AdventureWorksLH inneholder informasjon fra tre tabeller:

  • dimcustomer, for detaljert kundedemografi og kontaktinformasjon
  • dimdate, for datorelaterte data – for eksempel kalender- og regnskapsinformasjon
  • dimgeographyfor geografiske detaljer, inkludert bynavn og landsområdekoder.

Bruk denne datakilden for spørringer og analyser som involverer kundedetaljer, tidsbaserte hendelser og geografiske plasseringer.

Skjermbilde som viser hvor du kan gi instruksjonene til KUNSTIG INTELLIGENS.

Gi eksempler

Hvis du vil legge til eksempelspørringer, velger du Eksempelspørringer-knappen for å åpne eksempelspørringsruten til høyre. Denne ruten inneholder alternativer for å legge til eller redigere eksempelspørringer for alle støttede datakilder. For hver datakilde kan du velge Legg til eller rediger eksempelspørringer for å legge inn de relevante eksemplene, som vist i følgende skjermbilde:

Skjermbilde som viser hvor du kan legge til eksemplene du oppgir i AI-en.

Her bør du legge til eksempelspørringer for datakilden for lakehouse som du opprettet.

Question: Calculate the average percentage increase in sales amount for repeat purchases for every zipcode. Repeat purchase is a purchase subsequent to the first purchase (the average should always be computed relative to the first purchase)

SELECT AVG((s.SalesAmount - first_purchase.SalesAmount) / first_purchase.SalesAmount * 100) AS AvgPercentageIncrease
FROM factinternetsales s
INNER JOIN dimcustomer c ON s.CustomerKey = c.CustomerKey
INNER JOIN dimgeography g ON c.GeographyKey = g.GeographyKey
INNER JOIN (
	SELECT *
	FROM (
		SELECT
			CustomerKey,
			SalesAmount,
            OrderDate,
			ROW_NUMBER() OVER (PARTITION BY CustomerKey ORDER BY OrderDate) AS RowNumber
		FROM factinternetsales
	) AS t
	WHERE RowNumber = 1
) first_purchase ON s.CustomerKey = first_purchase.CustomerKey
WHERE s.OrderDate > first_purchase.OrderDate
GROUP BY g.PostalCode;

Question: Show the monthly total and year-to-date total sales. Order by year and month.

SELECT
    Year,
	Month,
	MonthlySales,
	SUM(MonthlySales) OVER (PARTITION BY Year ORDER BY Year, Month ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS CumulativeTotal
FROM (
	SELECT
	   YEAR(OrderDate) AS Year,
	   MONTH(OrderDate) AS Month,
	   SUM(SalesAmount) AS MonthlySales
	FROM factinternetsales
	GROUP BY YEAR(OrderDate), MONTH(OrderDate)
) AS t

Skjermbilde som viser hvordan du legger til SQL-eksempler.

Obs!

Å legge til eksempelspørrings-/spørsmålspar støttes for øyeblikket ikke for datakilder for semantisk modell for Power BI.

Teste og revidere AI-ferdigheten

Nå som du har konfigurert ai-ferdigheten, lagt til ai-instruksjoner og gitt eksempelspørringer for lakehouse, kan du samhandle med det ved å stille spørsmål og motta svar. Etter hvert som du fortsetter testingen, kan du legge til flere eksempler og finjustere instruksjonene for å forbedre ytelsen til AI-ferdighetene ytterligere. Samarbeid med kollegene dine for å samle inn tilbakemeldinger, og kontroller at de angitte eksempelspørringene og instruksjonene samsvarer med spørsmålstypene de vil stille.

Bruke AI-ferdigheter programmatisk

Du kan bruke kunstig intelligens programmatisk i en Fabric-notatblokk. Hvis du vil finne ut om AI-ferdigheten har en publisert nettadresseverdi, velger du Innstillinger, som vist i dette skjermbildet:

Skjermbilde som viser utvalg av ferdighetsinnstillinger for kunstig intelligens.

Før du publiserer AI-ferdigheten, har den ikke en publisert nettadresseverdi, som vist i dette skjermbildet:

Skjermbilde som viser at en AI-ferdighet ikke har en publisert nettadresseverdi før publisering.

Når du har validert ytelsen til ai-ferdigheten, kan du bestemme deg for å publisere den slik at du kan dele den med kollegene dine som ønsker å gjøre Q&A over data. I dette tilfellet velger du Publiser, som vist i dette skjermbildet:

Skjermbilde som viser valg av alternativet Publiser.

Den publiserte nettadressen for AI-ferdigheten vises, som vist i dette skjermbildet:

Skjermbilde som viser den publiserte URL-adressen.

Deretter kan du kopiere den publiserte nettadressen og bruke den i Fabric-notatblokken. På denne måten kan du spørre ai-ferdigheten ved å ringe til AI-kompetanse-API-en i en Fabric-notatblokk. Lim inn den kopierte URL-adressen i kodesnutten. Deretter erstatter du spørsmålet med alle spørringer som er relevante for ai-ferdighetene dine. Dette eksemplet brukes \<generic published URL value\> som URL-adresse.

%pip install "openai==1.14.1"

%pip install httpx==0.27.2

import requests
import json
import pprint
import typing as t
import time
import uuid

from openai import OpenAI
from openai._exceptions import APIStatusError
from openai._models import FinalRequestOptions
from openai._types import Omit
from openai._utils import is_given
from synapse.ml.mlflow import get_mlflow_env_config
from sempy.fabric._token_provider import SynapseTokenProvider
 
base_url = "https://<generic published base URL value>"
question = "What datasources do you have access to?"

configs = get_mlflow_env_config()

# Create OpenAI Client
class FabricOpenAI(OpenAI):
    def __init__(
        self,
        api_version: str ="2024-05-01-preview",
        **kwargs: t.Any,
    ) -> None:
        self.api_version = api_version
        default_query = kwargs.pop("default_query", {})
        default_query["api-version"] = self.api_version
        super().__init__(
            api_key="",
            base_url=base_url,
            default_query=default_query,
            **kwargs,
        )
    
    def _prepare_options(self, options: FinalRequestOptions) -> None:
        headers: dict[str, str | Omit] = (
            {**options.headers} if is_given(options.headers) else {}
        )
        options.headers = headers
        headers["Authorization"] = f"Bearer {configs.driver_aad_token}"
        if "Accept" not in headers:
            headers["Accept"] = "application/json"
        if "ActivityId" not in headers:
            correlation_id = str(uuid.uuid4())
            headers["ActivityId"] = correlation_id

        return super()._prepare_options(options)

# Pretty printing helper
def pretty_print(messages):
    print("---Conversation---")
    for m in messages:
        print(f"{m.role}: {m.content[0].text.value}")
    print()

fabric_client = FabricOpenAI()
# Create assistant
assistant = fabric_client.beta.assistants.create(model="not used")
# Create thread
thread = fabric_client.beta.threads.create()
# Create message on thread
message = fabric_client.beta.threads.messages.create(thread_id=thread.id, role="user", content=question)
# Create run
run = fabric_client.beta.threads.runs.create(thread_id=thread.id, assistant_id=assistant.id)

# Wait for run to complete
while run.status == "queued" or run.status == "in_progress":
    run = fabric_client.beta.threads.runs.retrieve(
        thread_id=thread.id,
        run_id=run.id,
    )
    print(run.status)
    time.sleep(2)

# Print messages
response = fabric_client.beta.threads.messages.list(thread_id=thread.id, order="asc")
pretty_print(response)

# Delete thread
fabric_client.beta.threads.delete(thread_id=thread.id)

Relatert innhold