Amazon SageMaker Studio tillhandahåller en helt hanterad lösning för datavetare för att interaktivt bygga, träna och distribuera modeller för maskininlärning (ML). I processen att arbeta med sina ML-uppgifter startar datavetare vanligtvis sitt arbetsflöde genom att upptäcka relevanta datakällor och ansluta till dem. De använder sedan SQL för att utforska, analysera, visualisera och integrera data från olika källor innan de använder dem i sin ML-träning och slutledning. Tidigare fann datavetare ofta på att jonglera med flera verktyg för att stödja SQL i deras arbetsflöde, vilket hindrade produktiviteten.

Vi är glada att kunna meddela att JupyterLab-anteckningsböcker i SageMaker Studio nu kommer med inbyggt stöd för SQL. Dataforskare kan nu:

• Anslut till populära datatjänster inklusive Amazonas Athena, Amazon RedShift, Amazon DataZone, och Snowflake direkt i anteckningsböckerna
• Bläddra och sök efter databaser, scheman, tabeller och vyer och förhandsgranska data i anteckningsbokens gränssnitt
• Blanda SQL- och Python-kod i samma anteckningsbok för effektiv utforskning och transformation av data för användning i ML-projekt
• Använd utvecklarproduktivitetsfunktioner som SQL-kommando, hjälp med kodformatering och syntaxmarkering för att påskynda kodutvecklingen och förbättra utvecklarens övergripande produktivitet

Dessutom kan administratörer säkert hantera anslutningar till dessa datatjänster, vilket gör att datavetare kan komma åt auktoriserad data utan att behöva hantera inloggningsuppgifter manuellt.

I det här inlägget guidar vi dig genom att ställa in den här funktionen i SageMaker Studio och guidar dig genom olika funktioner i den här funktionen. Sedan visar vi hur du kan förbättra SQL-upplevelsen i notebook med hjälp av text-till-SQL-funktioner som tillhandahålls av avancerade stora språkmodeller (LLM) för att skriva komplexa SQL-frågor med naturliga språktexter som indata. Slutligen, för att göra det möjligt för en bredare publik av användare att generera SQL-frågor från naturligt språkinmatning i sina anteckningsböcker, visar vi dig hur du distribuerar dessa Text-to-SQL-modeller med Amazon SageMaker slutpunkter.

Lösningsöversikt

Med SageMaker Studio JupyterLab Notebooks SQL-integrering kan du nu ansluta till populära datakällor som Snowflake, Athena, Amazon Redshift och Amazon DataZone. Denna nya funktion gör att du kan utföra olika funktioner.

Till exempel kan du visuellt utforska datakällor som databaser, tabeller och scheman direkt från ditt JupyterLab-ekosystem. Om dina notebook-miljöer körs på SageMaker Distribution 1.6 eller högre, leta efter en ny widget på vänster sida av ditt JupyterLab-gränssnitt. Detta tillägg förbättrar datatillgänglighet och hantering inom din utvecklingsmiljö.

Om du för närvarande inte använder den föreslagna SageMaker-distributionen (1.5 eller lägre) eller i en anpassad miljö, se bilagan för mer information.

När du har konfigurerat anslutningar (illustreras i nästa avsnitt) kan du lista dataanslutningar, bläddra i databaser och tabeller och inspektera scheman.

SageMaker Studio JupyterLabs inbyggda SQL-tillägg gör att du också kan köra SQL-frågor direkt från en anteckningsbok. Jupyter-anteckningsböcker kan skilja mellan SQL- och Python-kod med hjälp av %%sm_sql magiskt kommando, som måste placeras överst i alla celler som innehåller SQL-kod. Detta kommando signalerar till JupyterLab att följande instruktioner är SQL-kommandon snarare än Python-kod. Utdata från en fråga kan visas direkt i anteckningsboken, vilket underlättar sömlös integrering av SQL- och Python-arbetsflöden i din dataanalys.

Utdata från en fråga kan visas visuellt som HTML-tabeller, som visas i följande skärmdump.

De kan också skrivas till en pandas DataFrame.

Förutsättningar

Se till att du har uppfyllt följande förutsättningar för att använda SageMaker Studio notebook SQL-upplevelse:

• SageMaker Studio V2 – Se till att du kör den mest uppdaterade versionen av din SageMaker Studio-domän och användarprofiler. Om du för närvarande använder SageMaker Studio Classic, se Migrerar från Amazon SageMaker Studio Classic.
• IAM-roll – SageMaker kräver en AWS identitets- och åtkomsthantering (IAM) roll som ska tilldelas en SageMaker Studio-domän eller användarprofil för att hantera behörigheter effektivt. En uppdatering av exekveringsrollen kan krävas för att få in datasurfning och SQL-körningsfunktionen. Följande exempelpolicy gör det möjligt för användare att bevilja, lista och köra AWS-lim, Athena, Amazon enkel lagringstjänst (Amazon S3), AWS Secrets Manager, och Amazon Redshift-resurser:

  {
     "Version":"2012-10-17",
     "Statement":[
        {
           "Sid":"SQLRelatedS3Permissions",
           "Effect":"Allow",
           "Action":[
              "s3:ListBucket",
              "s3:GetObject",
              "s3:GetBucketLocation",
              "s3:ListMultipartUploadParts",
              "s3:AbortMultipartUpload",
              "s3:PutObject"
           ],
           "Resource":[
              "arn:aws:s3:::sagemaker*/*",
              "arn:aws:s3:::sagemaker*"
           ]
        },
        {
           "Sid":"GlueDataAccess",
           "Effect":"Allow",
           "Action":[
              "glue:GetDatabases",
              "glue:GetSchema",
              "glue:GetTables",
              "glue:GetDatabase",
              "glue:GetTable",
              "glue:ListSchemas",
              "glue:GetPartitions",
              "glue:GetConnections",
              "glue:GetConnection",
              "glue:CreateConnection"
           ],
           "Resource":[
              "arn:aws:glue:<region>:<account>:table/sagemaker*/*",
              "arn:aws:glue:<region>:<account>:database/sagemaker*",
              "arn:aws:glue:<region>:<account>:schema/sagemaker*",
              "arn:aws:glue:<region>:<account>:connection/sagemaker*",
              "arn:aws:glue:<region>:<account>:registry/sagemaker*",
              "arn:aws:glue:<region>:<account>:catalog"
           ]
        },
        {
           "Sid":"AthenaQueryExecution",
           "Effect":"Allow",
           "Action":[
              "athena:ListDataCatalogs",
              "athena:ListDatabases",
              "athena:ListTableMetadata",
              "athena:StartQueryExecution",
              "athena:GetQueryExecution",
              "athena:RunQuery",
              "athena:StartSession",
              "athena:GetQueryResults",
              "athena:ListWorkGroups",
              "athena:GetDataCatalog",
              "athena:GetWorkGroup"
           ],
           "Resource":[
              "arn:aws:athena:<region>:<account>:workgroup/sagemaker*",
              "arn:aws:athena:<region>:<account>:datacatalog/sagemaker*"
           ]
        },
        {
           "Sid":"GetSecretsAndCredentials",
           "Effect":"Allow",
           "Action":[
              "secretsmanager:GetSecretValue",
              "redshift:GetClusterCredentials"
           ],
           "Resource":[
              "arn:aws:secretsmanager:<region>:<account>:secret:sagemaker*",
              "arn:aws:redshift:<region>:<account>:dbuser:sagemaker*/sagemaker*",
              "arn:aws:redshift:<region>:<account>:dbgroup:sagemaker*/sagemaker*",
              "arn:aws:redshift:<region>:<account>:dbname:sagemaker*/sagemaker*"
           ]
        }
     ]
  }

• JupyterLab Space – Du behöver tillgång till den uppdaterade SageMaker Studio och JupyterLab Space med SageMaker Distribution v1.6 eller senare bildversioner. Om du använder anpassade bilder för JupyterLab Spaces eller äldre versioner av SageMaker Distribution (v1.5 eller lägre), se bilagan för instruktioner för att installera nödvändiga paket och moduler för att aktivera den här funktionen i dina miljöer. För att lära dig mer om SageMaker Studio JupyterLab Spaces, se Öka produktiviteten på Amazon SageMaker Studio: Vi introducerar JupyterLab Spaces och generativa AI-verktyg.

• Åtkomstuppgifter för datakälla – Denna anteckningsbokfunktion i SageMaker Studio kräver användarnamn och lösenordsåtkomst till datakällor som Snowflake och Amazon Redshift. Skapa användarnamn och lösenordsbaserad åtkomst till dessa datakällor om du inte redan har en. OAuth-baserad åtkomst till Snowflake är inte en funktion som stöds när detta skrivs.
• Ladda SQL magi – Innan du kör SQL-frågor från en Jupyter-anteckningsbokcell, är det viktigt att ladda SQL magics-tillägget. Använd kommandot %load_ext amazon_sagemaker_sql_magic för att aktivera den här funktionen. Dessutom kan du köra %sm_sql? kommando för att visa en omfattande lista över alternativ som stöds för att fråga från en SQL-cell. Dessa alternativ inkluderar bland annat att ställa in en standardfrågegräns på 1,000 XNUMX, köra en fullständig extrahering och injicera frågeparametrar. Denna inställning möjliggör flexibel och effektiv SQL-datamanipulation direkt i din notebook-miljö.

Skapa databasanslutningar

De inbyggda SQL-surfnings- och exekveringsmöjligheterna i SageMaker Studio förbättras av AWS Glue-anslutningar. En AWS Glue-anslutning är ett AWS Glue Data Catalog-objekt som lagrar viktig data som inloggningsuppgifter, URI-strängar och virtuell privat molninformation (VPC) för specifika datalager. Dessa anslutningar används av AWS Glue-sökrobotar, jobb och utvecklingsslutpunkter för att komma åt olika typer av datalager. Du kan använda dessa anslutningar för både käll- och måldata, och till och med återanvända samma anslutning över flera sökrobotar eller extrahera, transformera och ladda (ETL) jobb.

För att utforska SQL-datakällor i den vänstra rutan i SageMaker Studio måste du först skapa AWS Glue-anslutningsobjekt. Dessa anslutningar underlättar åtkomst till olika datakällor och låter dig utforska deras schematiska dataelement.

I följande avsnitt går vi igenom processen att skapa SQL-specifika AWS Glue-anslutningar. Detta gör att du kan komma åt, se och utforska datauppsättningar över en mängd olika datalager. För mer detaljerad information om AWS-limanslutningar, se Ansluter till data.

Skapa en AWS Glue-anslutning

Det enda sättet att ta med datakällor till SageMaker Studio är med AWS Glue-anslutningar. Du måste skapa AWS Glue-anslutningar med specifika anslutningstyper. När detta skrivs är den enda mekanismen som stöds för att skapa dessa anslutningar att använda AWS-kommandoradsgränssnitt (AWS CLI).

JSON-fil för anslutningsdefinition

När du ansluter till olika datakällor i AWS Glue måste du först skapa en JSON-fil som definierar anslutningsegenskaperna – kallad anslutningsdefinitionsfil. Den här filen är avgörande för att upprätta en AWS Glue-anslutning och bör specificera alla nödvändiga konfigurationer för att komma åt datakällan. För bästa säkerhetspraxis rekommenderar vi att du använder Secrets Manager för att säkert lagra känslig information som lösenord. Samtidigt kan andra anslutningsegenskaper hanteras direkt via AWS Glue-anslutningar. Detta tillvägagångssätt säkerställer att känsliga referenser skyddas samtidigt som anslutningskonfigurationen görs tillgänglig och hanterbar.

Följande är ett exempel på en anslutningsdefinition JSON:

{
    "ConnectionInput": {
        "Name": <GLUE_CONNECTION_NAME>,
        "Description": <GLUE_CONNECTION_DESCRIPTION>,
        "ConnectionType": "REDSHIFT | SNOWFLAKE | ATHENA",
        "ConnectionProperties": {
            "PythonProperties": "{"aws_secret_arn": <SECRET_ARN>, "database": <...>}"
        }
    }
}

När du konfigurerar AWS Glue-anslutningar för dina datakällor finns det några viktiga riktlinjer att följa för att tillhandahålla både funktionalitet och säkerhet:

• Stringifiering av fastigheter - Inom PythonProperties nyckel, se till att alla egenskaper är strängade nyckel-värdepar. Det är viktigt att undvika dubbla citattecken på rätt sätt genom att använda omvänt snedstreck () vid behov. Detta hjälper till att behålla rätt format och undvika syntaxfel i din JSON.
• Hantera känslig information – Även om det är möjligt att inkludera alla anslutningsegenskaper inom PythonProperties, är det tillrådligt att inte inkludera känsliga detaljer som lösenord direkt i dessa egenskaper. Använd istället Secrets Manager för att hantera känslig information. Detta tillvägagångssätt säkrar dina känsliga data genom att lagra dem i en kontrollerad och krypterad miljö, borta från de viktigaste konfigurationsfilerna.

Skapa en AWS Glue-anslutning med AWS CLI

När du har inkluderat alla nödvändiga fält i din JSON-fil för anslutningsdefinition är du redo att upprätta en AWS Glue-anslutning för din datakälla med hjälp av AWS CLI och följande kommando:

aws --region <REGION> glue create-connection 
--cli-input-json file:///path/to/file/connection/definition/file.json

Detta kommando initierar en ny AWS Glue-anslutning baserat på specifikationerna i din JSON-fil. Följande är en snabb uppdelning av kommandokomponenterna:

• -område – Detta anger AWS-regionen där din AWS Glue-anslutning kommer att skapas. Det är avgörande att välja den region där dina datakällor och andra tjänster finns för att minimera latens och uppfylla kraven på datauppehållstillstånd.
• –cli-input-json file:///path/to/file/connection/definition/file.json – Den här parametern styr AWS CLI att läsa ingångskonfigurationen från en lokal fil som innehåller din anslutningsdefinition i JSON-format.

Du bör kunna skapa AWS Glue-anslutningar med föregående AWS CLI-kommando från din Studio JupyterLab-terminal. På Fil meny, välj Nya och terminal.

Om create-connection kommandot körs framgångsrikt, bör du se din datakälla listad i SQL-webbläsarfönstret. Om du inte ser din datakälla i listan väljer du refresh för att uppdatera cachen.

Skapa en Snowflake-anslutning

I det här avsnittet fokuserar vi på att integrera en Snowflake-datakälla med SageMaker Studio. Att skapa Snowflake-konton, databaser och lager faller utanför omfattningen av detta inlägg. För att komma igång med Snowflake, se Snowflake användarguide. I det här inlägget koncentrerar vi oss på att skapa en Snowflake definition JSON-fil och upprätta en Snowflake-datakällanslutning med AWS Glue.

Skapa en Secrets Manager-hemlighet

Du kan ansluta till ditt Snowflake-konto genom att antingen använda ett användar-ID och lösenord eller använda privata nycklar. För att ansluta med ett användar-ID och lösenord måste du säkert lagra dina referenser i Secrets Manager. Som tidigare nämnts, även om det är möjligt att bädda in denna information under PythonProperties, rekommenderas det inte att lagra känslig information i vanligt textformat. Se alltid till att känslig data hanteras säkert för att undvika potentiella säkerhetsrisker.

För att lagra information i Secrets Manager, utför följande steg:

1. Välj på Secrets Manager-konsolen Lagra en ny hemlighet.
2. För Hemlig typväljer Annan typ av hemlighet.
3. Välj för nyckel-värdeparet Oformatterad text och skriv in följande:

   {
       "user":"TestUser",
       "password":"MyTestPassword",
       "account":"AWSSAGEMAKERTEST"
   }

4. Ange ett namn för din hemlighet, t.ex sm-sql-snowflake-secret.
5. Lämna de andra inställningarna som standard eller anpassa vid behov.
6. Skapa hemligheten.

Skapa en AWS-limanslutning för Snowflake

Som diskuterats tidigare är AWS Glue-anslutningar viktiga för att komma åt alla anslutningar från SageMaker Studio. Du kan hitta en lista över alla anslutningsegenskaper som stöds för Snowflake. Följande är ett exempel på anslutningsdefinitionen JSON för Snowflake. Byt ut platshållarvärdena med lämpliga värden innan du sparar den på disken:

{
    "ConnectionInput": {
        "Name": "Snowflake-Airlines-Dataset",
        "Description": "SageMaker-Snowflake Airlines Dataset",
        "ConnectionType": "SNOWFLAKE",
        "ConnectionProperties": {
            "PythonProperties": "{"aws_secret_arn": "arn:aws:secretsmanager:<region>:<account>:secret:sm-sql-snowflake-secret", "database": "SAGEMAKERDEMODATABASE1"}"
        }
    }
}

För att skapa ett AWS Glue-anslutningsobjekt för Snowflake-datakällan, använd följande kommando:

aws --region <REGION> glue create-connection 
--cli-input-json file:///path/to/file/snowflake/definition/file.json

Det här kommandot skapar en ny Snowflake-datakällanslutning i din SQL-webbläsarruta som är läsbar och du kan köra SQL-frågor mot den från din JupyterLab-anteckningsbokcell.

Skapa en Amazon Redshift-anslutning

Amazon Redshift är en helt hanterad, petabyte-skala datalagertjänst som förenklar och minskar kostnaderna för att analysera all din data med standard SQL. Proceduren för att skapa en Amazon Redshift-anslutning återspeglar nära det för en Snowflake-anslutning.

Skapa en Secrets Manager-hemlighet

I likhet med Snowflake-inställningarna, för att ansluta till Amazon Redshift med ett användar-ID och lösenord, måste du säkert lagra hemlighetsinformationen i Secrets Manager. Slutför följande steg:

1. Välj på Secrets Manager-konsolen Lagra en ny hemlighet.
2. För Hemlig typväljer Inloggningsuppgifter för Amazon Redshift-kluster.
3. Ange inloggningsuppgifterna som används för att logga in för att komma åt Amazon Redshift som datakälla.
4. Välj det rödskiftningskluster som är kopplat till hemligheterna.
5. Ange ett namn för hemligheten, t.ex sm-sql-redshift-secret.
6. Lämna de andra inställningarna som standard eller anpassa vid behov.
7. Skapa hemligheten.

Genom att följa dessa steg ser du till att dina anslutningsuppgifter hanteras på ett säkert sätt, genom att använda de robusta säkerhetsfunktionerna i AWS för att hantera känslig data effektivt.

Skapa en AWS Glue-anslutning för Amazon Redshift

För att skapa en anslutning med Amazon Redshift med en JSON-definition, fyll i de nödvändiga fälten och spara följande JSON-konfiguration på disken:

{
    "ConnectionInput": {
        "Name": "Redshift-US-Housing-Dataset",
        "Description": "sagemaker redshift us housing dataset connection",
        "ConnectionType": "REDSHIFT",
        "ConnectionProperties": {
            "PythonProperties": "{"aws_secret_arn": "arn:aws:secretsmanager:<region>:<account>:sm-sql-redshift-secret", "database": "us-housing-database"}"
        }
    }
}

För att skapa ett AWS Glue-anslutningsobjekt för Redshift-datakällan, använd följande AWS CLI-kommando:

aws --region <REGION> glue create-connection 
--cli-input-json file:///path/to/file/redshift/definition/file.json

Detta kommando skapar en anslutning i AWS Glue länkad till din Redshift-datakälla. Om kommandot körs framgångsrikt kommer du att kunna se din Redshift-datakälla i SageMaker Studio JupyterLab-anteckningsboken, redo för att köra SQL-frågor och utföra dataanalys.

Skapa en Athena-anslutning

Athena är en fullständigt hanterad SQL-frågetjänst från AWS som möjliggör analys av data lagrad i Amazon S3 med standard SQL. För att ställa in en Athena-anslutning som en datakälla i JupyterLab-anteckningsbokens SQL-webbläsare måste du skapa en Athena-exempel på anslutningsdefinitionen JSON. Följande JSON-struktur konfigurerar nödvändiga detaljer för att ansluta till Athena, och specificerar datakatalogen, S3-staging-katalogen och regionen:

{
    "ConnectionInput": {
        "Name": "Athena-Credit-Card-Fraud",
        "Description": "SageMaker-Athena Credit Card Fraud",
        "ConnectionType": "ATHENA",
        "ConnectionProperties": {
            "PythonProperties": "{"catalog_name": "AwsDataCatalog","s3_staging_dir": "s3://sagemaker-us-east-2-123456789/athena-data-source/credit-card-fraud/", "region_name": "us-east-2"}"
        }
    }
}

För att skapa ett AWS Glue-anslutningsobjekt för Athena-datakällan, använd följande AWS CLI-kommando:

aws --region <REGION> glue create-connection 
--cli-input-json file:///path/to/file/athena/definition/file.json

Om kommandot lyckas kommer du att kunna komma åt Athena datakatalog och tabeller direkt från SQL-webbläsaren i din SageMaker Studio JupyterLab-anteckningsbok.

Fråga efter data från flera källor

Om du har flera datakällor integrerade i SageMaker Studio genom den inbyggda SQL-webbläsaren och SQL-funktionen för notebook, kan du snabbt köra frågor och enkelt växla mellan datakällans backends i efterföljande celler i en anteckningsbok. Denna förmåga möjliggör sömlösa övergångar mellan olika databaser eller datakällor under ditt analysarbetsflöde.

Du kan köra frågor mot en mångsidig samling av datakällors backends och föra resultaten direkt till Python-utrymmet för vidare analys eller visualisering. Detta underlättas av %%sm_sql magiskt kommando tillgängligt i SageMaker Studio-anteckningsböcker. För att mata ut resultaten av din SQL-fråga till en pandas DataFrame finns det två alternativ:

• Välj utdatatyp i verktygsfältet i anteckningsbokens cell DataFrame och namnge din DataFrame-variabel
• Lägg till följande parameter till din %%sm_sql kommando:

  --output '{"format": "DATAFRAME", "dataframe_name": "df"}'

Följande diagram illustrerar detta arbetsflöde och visar hur du enkelt kan köra frågor över olika källor i efterföljande anteckningsbokceller, samt träna en SageMaker-modell med hjälp av träningsjobb eller direkt i anteckningsboken med hjälp av lokal beräkning. Dessutom belyser diagrammet hur den inbyggda SQL-integrationen av SageMaker Studio förenklar processerna för utvinning och byggnad direkt i den välbekanta miljön i en JupyterLab-anteckningsbokcell.

Text till SQL: Använder naturligt språk för att förbättra författandet av frågor

SQL är ett komplext språk som kräver förståelse för databaser, tabeller, syntaxer och metadata. Idag kan generativ artificiell intelligens (AI) göra det möjligt för dig att skriva komplexa SQL-frågor utan att kräva djupgående SQL-erfarenhet. Utvecklingen av LLM:er har avsevärt påverkat naturlig språkbehandling (NLP)-baserad SQL-generering, vilket gör det möjligt att skapa exakta SQL-frågor från beskrivningar av naturliga språk – en teknik som kallas text-till-SQL. Det är dock viktigt att erkänna de inneboende skillnaderna mellan mänskligt språk och SQL. Mänskligt språk kan ibland vara tvetydigt eller oprecist, medan SQL är strukturerat, explicit och entydigt. Att överbrygga detta gap och korrekt omvandla naturligt språk till SQL-frågor kan utgöra en formidabel utmaning. När de förses med lämpliga uppmaningar kan LLM:er hjälpa till att överbrygga detta gap genom att förstå avsikten bakom det mänskliga språket och generera korrekta SQL-frågor i enlighet därmed.

Med lanseringen av SageMaker Studios SQL-frågefunktion i notebook gör SageMaker Studio det enkelt att inspektera databaser och scheman och skapa, köra och felsöka SQL-frågor utan att någonsin lämna Jupyter notebook-IDE. Det här avsnittet utforskar hur text-till-SQL-funktionerna hos avancerade LLM:er kan underlätta genereringen av SQL-frågor med naturligt språk i Jupyter-anteckningsböcker. Vi använder den senaste text-till-SQL-modellen defog/sqlcoder-7b-2 i kombination med Jupyter AI, en generativ AI-assistent speciellt designad för Jupyter-datorer, för att skapa komplexa SQL-frågor från naturligt språk. Genom att använda denna avancerade modell kan vi enkelt och effektivt skapa komplexa SQL-frågor med naturligt språk, och därigenom förbättra vår SQL-upplevelse inom bärbara datorer.

Prototyper för bärbar dator med Hugging Face Hub

För att börja skapa prototyper behöver du följande:

• GitHub-kod – Koden som presenteras i det här avsnittet är tillgänglig i följande GitHub repo och genom att hänvisa till exempel anteckningsbok.
• JupyterLab Space – Tillgång till ett SageMaker Studio JupyterLab-utrymme som backas upp av GPU-baserade instanser är viktigt. För defog/sqlcoder-7b-2 modell, en 7B-parametermodell, med en ml.g5.2xlarge-instans rekommenderas. Alternativ som t.ex defog/sqlcoder-70b-alpha eller defog/sqlcoder-34b-alpha är också genomförbara för konvertering av naturligt språk till SQL, men större instanstyper kan krävas för prototypframställning. Se till att du har kvoten för att starta en GPU-stödd instans genom att navigera till Service Quotas-konsolen, söka efter SageMaker och söka efter Studio JupyterLab Apps running on <instance type>.

Starta en ny GPU-stödd JupyterLab Space från din SageMaker Studio. Det rekommenderas att skapa ett nytt JupyterLab Space med minst 75 GB Amazon Elastic Block Store (Amazon EBS) lagring för en 7B parametermodell.

• Kramar Face Hub – Om din SageMaker Studio-domän har tillgång till att ladda ner modeller från Kramar Face Hub, kan du använda AutoModelForCausalLM klass från huggingface/transformatorer för att automatiskt ladda ner modeller och fästa dem på dina lokala grafikprocessorer. Modellvikterna kommer att lagras i din lokala maskins cache. Se följande kod:

  model_id = "defog/sqlcoder-7b-2" # or use "defog/sqlcoder-34b-alpha", "defog/sqlcoder-70b-alpha
  
  # download model and tokenizer in fp16 and pin model to local notebook GPUs
  model = AutoModelForCausalLM.from_pretrained(
      model_id, 
      device_map="auto",
      torch_dtype=torch.float16
  )
  
  tokenizer = AutoTokenizer.from_pretrained(model_id)
  tokenizer.pad_token = tokenizer.eos_token

Efter att modellen har laddats ner helt och laddats in i minnet bör du observera en ökning av GPU-användningen på din lokala dator. Detta indikerar att modellen aktivt använder GPU-resurserna för beräkningsuppgifter. Du kan verifiera detta i ditt eget JupyterLab-utrymme genom att köra nvidia-smi (för en engångsvisning) eller nvidia-smi —loop=1 (för att upprepa varje sekund) från din JupyterLab-terminal.

Text-till-SQL-modeller utmärker sig när det gäller att förstå avsikten och sammanhanget för en användares begäran, även när språket som används är konversationsrikt eller tvetydigt. Processen innebär att indata från naturligt språk översätts till korrekta databasschemaelement, såsom tabellnamn, kolumnnamn och villkor. Men en standardmodell av text-till-SQL kommer inte att känna till strukturen i ditt datalager, de specifika databasscheman eller kunna korrekt tolka innehållet i en tabell baserat enbart på kolumnnamn. För att effektivt använda dessa modeller för att generera praktiska och effektiva SQL-frågor från naturligt språk, är det nödvändigt att anpassa SQL-textgenereringsmodellen till ditt specifika lagerdatabasschema. Denna anpassning underlättas genom användning av LLM-meddelanden. Följande är en rekommenderad promptmall för defog/sqlcoder-7b-2 Text-to-SQL-modellen, uppdelad i fyra delar:

• uppgift – Det här avsnittet bör specificera en uppgift på hög nivå som ska utföras av modellen. Den bör inkludera typen av databasbackend (som Amazon RDS, PostgreSQL eller Amazon Redshift) för att göra modellen medveten om eventuella nyanserade syntaktiska skillnader som kan påverka genereringen av den slutliga SQL-frågan.
• Instruktioner – Det här avsnittet bör definiera uppgiftsgränser och domänmedvetenhet för modellen, och kan innehålla några få exempel för att vägleda modellen i att generera finjusterade SQL-frågor.
• Databas Schema – Det här avsnittet bör beskriva dina lagerdatabasscheman och beskriva relationerna mellan tabeller och kolumner för att hjälpa modellen att förstå databasstrukturen.
• Svar – Det här avsnittet är reserverat för modellen att mata ut SQL-frågans svar på det naturliga språkinmatningen.

Ett exempel på databasschemat och prompten som används i det här avsnittet finns i GitHub Repo.

### Task
Generate a SQL query to answer [QUESTION]{user_question}[/QUESTION]

### Instructions
- If you cannot answer the question with the available database schema, return 'I do not know'

### Database Schema
The query will run on a database with the following schema:
{table_metadata_string_DDL_statements}

### Answer
Given the database schema, here is the SQL query that 
 [QUESTION]
    {user_question}
 [/QUESTION]

[SQL]

Snabb ingenjörskonst handlar inte bara om att skapa frågor eller påståenden; det är en nyanserad konst och vetenskap som avsevärt påverkar kvaliteten på interaktioner med en AI-modell. Sättet du skapar en prompt kan djupt påverka arten och användbarheten av AI:s svar. Denna färdighet är avgörande för att maximera potentialen för AI-interaktioner, särskilt i komplexa uppgifter som kräver specialiserad förståelse och detaljerade svar.

Det är viktigt att ha möjlighet att snabbt bygga och testa en modells svar för en given prompt och optimera prompten baserat på svaret. JupyterLabs bärbara datorer ger möjligheten att ta emot omedelbar modellfeedback från en modell som körs på lokal dator och optimera prompten och justera en modells svar ytterligare eller ändra en modell helt. I det här inlägget använder vi en SageMaker Studio JupyterLab-notebook med stöd av ml.g5.2xlarges NVIDIA A10G 24 GB GPU för att köra text-till-SQL-modellinferens på notebook-datorn och interaktivt bygga vår modellprompt tills modellens svar är tillräckligt avstämt för att ge svar som är direkt körbara i JupyterLabs SQL-celler. För att köra modellinferens och samtidigt streama modellsvar använder vi en kombination av model.generate och TextIteratorStreamer enligt definitionen i följande kod:

streamer = TextIteratorStreamer(
    tokenizer=tokenizer, 
    timeout=240.0, 
    skip_prompt=True, 
    skip_special_tokens=True
)


def llm_generate_query(user_question):
    """ Generate text-gen SQL responses"""
    
    updated_prompt = prompt.format(question=user_question)
    inputs = tokenizer(updated_prompt, return_tensors="pt").to("cuda")
    
    return model.generate(
        **inputs,
        num_return_sequences=1,
        eos_token_id=tokenizer.eos_token_id,
        pad_token_id=tokenizer.eos_token_id,
        max_new_tokens=1024,
        temperature=0.1,
        do_sample=False,
        num_beams=1, 
        streamer=streamer,
    )

Modellens utdata kan dekoreras med SageMaker SQL-magi %%sm_sql ..., vilket gör att JupyterLab-anteckningsboken kan identifiera cellen som en SQL-cell.

Host Text-to-SQL-modeller som SageMaker-slutpunkter

I slutet av prototypstadiet har vi valt vår föredragna Text-to-SQL LLM, ett effektivt promptformat och en lämplig instanstyp för modellen (antingen enkel-GPU eller multi-GPU). SageMaker underlättar skalbar värd för anpassade modeller genom användning av SageMaker-slutpunkter. Dessa endpoints kan definieras enligt specifika kriterier, vilket möjliggör distribution av LLMs som endpoints. Denna förmåga gör att du kan skala lösningen till en bredare publik, vilket gör att användare kan generera SQL-frågor från naturliga språkingångar med hjälp av anpassade värdbaserade LLM:er. Följande diagram illustrerar denna arkitektur.

För att vara värd för din LLM som en SageMaker-slutpunkt genererar du flera artefakter.

Den första artefakten är modellvikter. SageMaker Deep Java Library (DJL) servering behållare låter dig ställa in konfigurationer genom en meta serveringsegenskaper fil, som gör att du kan styra hur modeller hämtas – antingen direkt från Hugging Face Hub eller genom att ladda ner modellartefakter från Amazon S3. Om du specificerar model_id=defog/sqlcoder-7b-2, DJL Serving kommer att försöka ladda ner den här modellen direkt från Hugging Face Hub. Däremot kan du ådra dig avgifter för intrång/utgående nätverk varje gång slutpunkten distribueras eller skalas elastiskt. För att undvika dessa avgifter och potentiellt påskynda nedladdningen av modellartefakter, rekommenderas att du hoppar över användningen model_id in serving.properties och spara modellvikter som S3-artefakter och endast specificera dem med s3url=s3://path/to/model/bin.

Att spara en modell (med dess tokenizer) till disk och ladda upp den till Amazon S3 kan åstadkommas med bara några rader kod:

# save model and tokenizer to local disk
model.save_pretrained(local_model_path)
tokenizer.save_pretrained(local_model_path)
...
...
...
# upload file to s3
s3_bucket_name = "<my llm artifact bucket name>>"
# s3 prefix to save model weights and tokenizer defs
model_s3_prefix = "sqlcoder-7b-instruct/weights"
# s3 prefix to store s
meta_model_s3_prefix = "sqlcoder-7b-instruct/meta-model"

sagemaker.s3.S3Uploader.upload(local_model_path,  f"s3://{s3_bucket_name}/{model_s3_prefix}")

Du använder också en databaspromptfil. I den här inställningen består databasprompten av Task, Instructions, Database Schemaoch Answer sections. För den aktuella arkitekturen allokerar vi en separat promptfil för varje databasschema. Det finns dock flexibilitet att utöka denna inställning till att inkludera flera databaser per promptfil, vilket gör att modellen kan köra sammansatta kopplingar över databaser på samma server. Under vårt prototypskapande sparar vi databasprompten som en textfil med namnet <Database-Glue-Connection-Name>.promptDär Database-Glue-Connection-Name motsvarar det anslutningsnamn som är synligt i din JupyterLab-miljö. Till exempel hänvisar det här inlägget till en Snowflake-anslutning som heter Airlines_Dataset, så databaspromptfilen heter Airlines_Dataset.prompt. Denna fil lagras sedan på Amazon S3 och läses och cachelagras sedan av vår modelltjänstlogik.

Dessutom tillåter denna arkitektur alla auktoriserade användare av denna slutpunkt att definiera, lagra och generera naturligt språk till SQL-frågor utan att behöva flera omdistribueringar av modellen. Vi använder följande exempel på en databasprompt för att demonstrera text-till-SQL-funktionaliteten.

Därefter genererar du servicelogik för anpassad modell. I det här avsnittet beskriver du en anpassad slutledningslogik som heter modell.py. Det här skriptet är utformat för att optimera prestandan och integrationen av våra text-till-SQL-tjänster:

• Definiera logiken för cachelagring av databasprompten – För att minimera latensen implementerar vi en anpassad logik för nedladdning och cachning av databaspromptfiler. Den här mekanismen säkerställer att uppmaningar är lättillgängliga, vilket minskar de omkostnader som är förknippade med frekventa nedladdningar.
• Definiera anpassad modellinferenslogik – För att öka inferenshastigheten laddas vår text-till-SQL-modell i precisionsformatet float16 och konverteras sedan till en DeepSpeed-modell. Detta steg möjliggör mer effektiv beräkning. Dessutom, inom denna logik, anger du vilka parametrar användare kan justera under slutledningssamtal för att skräddarsy funktionaliteten efter deras behov.
• Definiera anpassad in- och utgångslogik – Att etablera tydliga och skräddarsydda in-/utdataformat är avgörande för smidig integration med nedströmsapplikationer. En sådan applikation är JupyterAI, som vi diskuterar i det efterföljande avsnittet.

%%writefile {meta_model_filename}/model.py
...

predictor = None
prompt_for_db_dict_cache = {}

def download_prompt_from_s3(prompt_filename):

    print(f"downloading prompt file: {prompt_filename}")
    s3 = boto3.resource('s3')
    ...


def get_model(properties):
    
    ...
    print(f"Loading model from {cwd}")
    model = AutoModelForCausalLM.from_pretrained(
        cwd, 
        low_cpu_mem_usage=True, 
        torch_dtype=torch.bfloat16
    )
    model = deepspeed.init_inference(
        model, 
        mp_size=properties["tensor_parallel_degree"]
    )
    
    ...


def handle(inputs: Input) -> None:

    ...

    global predictor
    if not predictor:
        predictor = get_model(inputs.get_properties())

    ...
    result = f"""%%sm_sql --metastore-id {prompt_for_db_key.split('.')[0]} --metastore-type GLUE_CONNECTIONnn{result}n"""
    result = [{'generated_text': result}]
    
    return Output().add(result)

Dessutom inkluderar vi en serving.properties fil, som fungerar som en global konfigurationsfil för modeller som har DJL-servering. För mer information, se Konfigurationer och inställningar.

Slutligen kan du också inkludera en requirements.txt fil för att definiera ytterligare moduler som krävs för slutledning och paketera allt till en tarball för distribution.

Se följande kod:

os.system(f"tar czvf {meta_model_filename}.tar.gz ./{meta_model_filename}/")

>>>./deepspeed-djl-serving-7b/
>>>./deepspeed-djl-serving-7b/serving.properties
>>>./deepspeed-djl-serving-7b/model.py
>>>./deepspeed-djl-serving-7b/requirements.txt

Integrera din slutpunkt med SageMaker Studio Jupyter AI-assistent

Jupyter AI är ett verktyg med öppen källkod som ger generativ AI till Jupyters bärbara datorer, och erbjuder en robust och användarvänlig plattform för att utforska generativa AI-modeller. Det förbättrar produktiviteten i JupyterLab och Jupyter bärbara datorer genom att tillhandahålla funktioner som %%ai magin för att skapa en generativ AI-lekplats i bärbara datorer, ett inbyggt chatt-gränssnitt i JupyterLab för att interagera med AI som en konversationsassistent och stöd för ett brett utbud av LLM:er från leverantörer gillar Amazon Titan, AI21, Anthropic, Cohere och Hugging Face eller hanterade tjänster som Amazonas berggrund och SageMaker-slutpunkter. För det här inlägget använder vi Jupyter AI:s out-of-the-box-integrering med SageMaker-slutpunkter för att föra in text-till-SQL-kapaciteten i JupyterLab-anteckningsböcker. Jupyter AI-verktyget kommer förinstallerat i alla SageMaker Studio JupyterLab Spaces med stöd av SageMaker Distribution bilder; slutanvändare behöver inte göra några ytterligare konfigurationer för att börja använda Jupyter AI-tillägget för att integrera med en SageMaker-värdad slutpunkt. I det här avsnittet diskuterar vi de två sätten att använda det integrerade Jupyter AI-verktyget.

Jupyter AI inuti en anteckningsbok med hjälp av magi

Jupyter AI %%ai magiskt kommando låter dig förvandla dina SageMaker Studio JupyterLab-anteckningsböcker till en reproducerbar generativ AI-miljö. För att börja använda AI-magics, se till att du har laddat tillägget jupyter_ai_magics att använda %%ai magi, och dessutom ladda amazon_sagemaker_sql_magic att använda %%sm_sql magi:

# load sm_sql magic extension and ai magic extension
%load_ext jupyter_ai_magics
%load_ext amazon_sagemaker_sql_magic

För att ringa ett samtal till din SageMaker-slutpunkt från din bärbara dator med hjälp av %%ai magiskt kommando, ange följande parametrar och strukturera kommandot enligt följande:

• –regionsnamn – Ange den region där din slutpunkt är utplacerad. Detta säkerställer att förfrågan dirigeras till rätt geografisk plats.
• –request-schema – Inkludera schemat för indata. Detta schema beskriver det förväntade formatet och de typer av indata som din modell behöver för att bearbeta begäran.
• –svarsväg – Definiera sökvägen inom responsobjektet där utdata från din modell finns. Denna sökväg används för att extrahera relevant data från svaret som returneras av din modell.
• -f (valfritt) - Detta är en utdataformaterare flagga som anger vilken typ av utdata som returneras av modellen. I samband med en Jupyter-anteckningsbok, om utdata är kod, bör denna flagga ställas in i enlighet med detta för att formatera utdata som körbar kod överst i en Jupyter-anteckningsbokcell, följt av ett fritextinmatningsområde för användarinteraktion.

Till exempel kan kommandot i en Jupyter-anteckningsbokscell se ut som följande kod:

%%ai sagemaker-endpoint:<endpoint-name> --region-name=us-east-1 
--request-schema={
    "inputs":"<prompt>", 
    "parameters":{
        "temperature":0.1,
        "top_p":0.2,
        "max_new_tokens":1024,
        "return_full_text":false
    }, 
    "db_prompt":"Airlines_Dataset.prompt"
  } 
--response-path=[0].generated_text -f code

My natural language query goes here...

Jupyter AI chattfönster

Alternativt kan du interagera med SageMaker-slutpunkter genom ett inbyggt användargränssnitt, vilket förenklar processen att generera frågor eller delta i dialog. Innan du börjar chatta med din SageMaker-slutpunkt, konfigurera de relevanta inställningarna i Jupyter AI för SageMaker-slutpunkten, som visas i följande skärmdump.

Slutsats

SageMaker Studio förenklar och effektiviserar nu dataforskarnas arbetsflöde genom att integrera SQL-stöd i JupyterLab-anteckningsböcker. Detta gör att datavetare kan fokusera på sina uppgifter utan att behöva hantera flera verktyg. Dessutom gör den nya inbyggda SQL-integrationen i SageMaker Studio det möjligt för datapersonas att utan ansträngning generera SQL-frågor med naturliga språktexter som indata, och därmed accelerera deras arbetsflöde.

Vi uppmuntrar dig att utforska dessa funktioner i SageMaker Studio. För mer information, se Förbered data med SQL i Studio.

Appendix

Aktivera SQL-webbläsaren och anteckningsbokens SQL-cell i anpassade miljöer

Om du inte använder en SageMaker Distribution-bild eller använder Distribution Images 1.5 eller lägre, kör följande kommandon för att aktivera SQL-sökningsfunktionen i din JupyterLab-miljö:

npm install -g vscode-jsonrpc
npm install -g sql-language-server
pip install amazon-sagemaker-sql-execution==0.1.0
pip install amazon-sagemaker-sql-editor
restart-jupyter-server

Flytta SQL-webbläsarwidgeten

JupyterLab-widgets möjliggör omlokalisering. Beroende på dina önskemål kan du flytta widgets till vardera sidan av JupyterLabs widgetpanel. Om du föredrar det kan du flytta SQL-widgetens riktning till motsatt sida (höger till vänster) av sidofältet med ett enkelt högerklick på widgetikonen och välja Byt sidofältssida.

Om författarna

Pranav Murthy är en AI/ML Specialist Solutions Architect på AWS. Han fokuserar på att hjälpa kunder att bygga, träna, distribuera och migrera maskininlärning (ML) arbetsbelastningar till SageMaker. Han har tidigare arbetat i halvledarindustrin med att utveckla modeller för stora datorseende (CV) och NLP (natural language processing) för att förbättra halvledarprocesser med hjälp av toppmoderna ML-tekniker. På fritiden tycker han om att spela schack och att resa. Du kan hitta Pranav på LinkedIn.

Varun Shah är en mjukvaruingenjör som arbetar på Amazon SageMaker Studio på Amazon Web Services. Han är fokuserad på att bygga interaktiva ML-lösningar som förenklar databehandling och dataförberedande resor. På sin fritid tycker Varun om utomhusaktiviteter inklusive vandring och skidåkning, och är alltid redo för att upptäcka nya, spännande platser.

Sumedha Swamy är en huvudproduktchef på Amazon Web Services där han leder SageMaker Studio-teamet i dess uppdrag att utveckla IDE-valet för datavetenskap och maskininlärning. Han har ägnat de senaste 15 åren åt att bygga maskininlärningsbaserade konsument- och företagsprodukter.

Bosco Albuquerque är Sr. Partner Solutions Architect på AWS och har över 20 års erfarenhet av att arbeta med databas- och analysprodukter från företagsdatabasleverantörer och molnleverantörer. Han har hjälpt teknikföretag att designa och implementera dataanalyslösningar och produkter.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/explore-data-with-ease-using-sql-and-text-to-sql-in-amazon-sagemaker-studio-jupyterlab-notebooks/