Zephyrnet-logo

Generatieve data-intelligentie

AI

Grote taalmodel-gevolgtrekking over vertrouwelijke gegevens met behulp van AWS Nitro Enclaves | Amazon-webservices

Heruitgegeven door Plato
Heruitgegeven door Plato

Datum:

Aantal keer bekeken: 32

Dit bericht is geschreven in samenwerking met Justin Miles, Liv d'Aliberti en Joe Kovba van Leidos. 

Leidos is een leider in wetenschappelijke en technologische oplossingen in de Fortune 500 en werkt aan het aanpakken van enkele van 's werelds zwaarste uitdagingen op het gebied van defensie, inlichtingen, binnenlandse veiligheid, civiele zaken en gezondheidszorg. In dit bericht bespreken we hoe Leidos samenwerkte met AWS om een ​​aanpak te ontwikkelen voor privacybehoudende grote taalmodel (LLM)-inferentie met behulp van AWS Nitro-enclaves.

LLM's zijn ontworpen om mensachtige taal te begrijpen en te genereren, en worden in veel sectoren gebruikt, waaronder de overheid, de gezondheidszorg, de financiële sector en de intellectuele eigendom. LLM's zijn breed toepasbaar, waaronder chatbots, het genereren van inhoud, taalvertaling, sentimentanalyse, vraagantwoordsystemen, zoekmachines en het genereren van code. Het introduceren van op LLM gebaseerde gevolgtrekkingen in een systeem heeft ook het potentieel om privacybedreigingen te introduceren, waaronder modelexfiltratie, schendingen van de gegevensprivacy en onbedoelde, op LLM gebaseerde servicemanipulatie. Er moeten technische architecturen worden geïmplementeerd om ervoor te zorgen dat LLM's tijdens gevolgtrekking geen gevoelige informatie vrijgeven.

In dit bericht wordt besproken hoe Nitro Enclaves kan helpen bij het beschermen van LLM-modelimplementaties, met name die waarbij persoonlijk identificeerbare informatie (PII) of beschermde gezondheidsinformatie (PHI) wordt gebruikt. Dit bericht is alleen voor educatieve doeleinden en mag niet worden gebruikt in productieomgevingen zonder aanvullende controles.

Overzicht van LLM's en Nitro-enclaves

Een mogelijke use case is een op LLM gebaseerde chatbot voor gevoelige zoekopdrachten die is ontworpen om een ​​vraag- en antwoordservice uit te voeren die PII en PHI bevat. De meeste huidige LLM-chatbotoplossingen informeren gebruikers expliciet dat ze vanwege veiligheidsredenen geen PII of PHI mogen opnemen bij het invoeren van vragen. Om deze zorgen weg te nemen en klantgegevens te beschermen, vertrouwen service-eigenaren voornamelijk op gebruikersbeschermingen zoals de volgende:

  • Redaction – Het proces van het identificeren en verbergen van gevoelige informatie zoals PII in documenten, teksten of andere vormen van inhoud. Dit kan worden bereikt met invoergegevens voordat deze naar een model of een LLM worden verzonden die is getraind om hun antwoorden automatisch te redigeren.
  • Multi-factor authenticatie – Een beveiligingsproces waarbij gebruikers meerdere authenticatiemethoden moeten opgeven om hun identiteit te verifiëren en toegang te krijgen tot de LLM.
  • Transport Layer Security (TLS) – Een cryptografisch protocol dat veilige communicatie biedt die de gegevensprivacy verbetert tijdens de overdracht tussen gebruikers en de LLM-service.

Hoewel deze praktijken de beveiliging van de dienst verbeteren, zijn ze niet voldoende om alle gevoelige gebruikersinformatie en andere gevoelige informatie die zonder medeweten van de gebruiker kan blijven bestaan, te beschermen.

In ons voorbeeldgebruik is een LLM-service ontworpen om vragen over gezondheidszorguitkeringen van werknemers te beantwoorden of om een ​​persoonlijk pensioenplan te bieden. Laten we de volgende voorbeeldarchitectuur analyseren en risicogebieden voor gegevensprivacy identificeren.

llm-risicogebied-diagram

Figuur 1 – Diagram van risicogebieden voor gegevensprivacy

De potentiële risicogebieden zijn als volgt:

  1. Geprivilegieerde gebruikers hebben toegang tot het exemplaar waarin de server zich bevindt. Onbedoelde of ongeoorloofde wijzigingen aan de service kunnen ertoe leiden dat gevoelige gegevens op onbedoelde manieren openbaar worden gemaakt.
  2. Gebruikers moeten erop vertrouwen dat de service geen gevoelige informatie vrijgeeft of bewaart in applicatielogboeken.
  3. Wijzigingen in applicatiepakketten kunnen wijzigingen in de service veroorzaken, waardoor gevoelige gegevens openbaar worden gemaakt.
  4. Bevoorrechte gebruikers met toegang tot het exemplaar hebben onbeperkte toegang tot de LLM die door de service wordt gebruikt. Wijzigingen kunnen ertoe leiden dat onjuiste of onnauwkeurige informatie aan gebruikers wordt geretourneerd.

Nitro Enclaves biedt extra isolatie voor uw Amazon Elastic Compute-cloud (Amazon EC2), waarbij gegevens die in gebruik zijn, worden beschermd tegen ongeoorloofde toegang, inclusief gebruikers op beheerdersniveau. In de voorgaande architectuur is het mogelijk dat een onbedoelde wijziging ertoe leidt dat gevoelige gegevens in platte tekst blijven bestaan ​​en per ongeluk aan een gebruiker worden onthuld die mogelijk geen toegang tot die gegevens nodig heeft. Met Nitro Enclaves creëert u een geïsoleerde omgeving van uw EC2-instantie, waardoor u CPU- en geheugenbronnen aan de enclave kunt toewijzen. Deze enclave is een zeer restrictieve virtuele machine. Door code uit te voeren die gevoelige gegevens binnen de enclave verwerkt, kan geen van de bovenliggende processen de enclavegegevens bekijken.

Nitro Enclaves biedt de volgende voordelen:

  • Geheugen- en CPU-isolatie – Het is afhankelijk van de Nitro Hypervisor om de CPU en het geheugen van de enclave te isoleren van gebruikers, applicaties en bibliotheken op de bovenliggende instantie. Deze functie helpt bij het isoleren van de enclave en uw software, en verkleint aanzienlijk de oppervlakte voor onbedoelde gebeurtenissen.
  • Aparte virtuele machine – Enclaves zijn gescheiden virtuele machines die aan een EC2-instantie zijn gekoppeld om zeer gevoelige gegevens verder te beschermen en veilig te verwerken.
  • Geen interactieve toegang – Enclaves bieden alleen veilige lokale socketconnectiviteit met hun bovenliggende instantie. Ze hebben geen permanente opslag, interactieve toegang of externe netwerken.
  • Cryptografische attestatie – Nitro Enclaves-aanbiedingen cryptografische attestatie, een proces dat wordt gebruikt om de identiteit van een enclave te bewijzen en te verifiëren dat alleen geautoriseerde code in uw enclave wordt uitgevoerd.
  • AWS-integratie – Nitro Enclaves is geïntegreerd met AWS Sleutelbeheerservice (AWS KMS), waarmee u bestanden kunt decoderen die zijn gecodeerd met AWS KMS binnen de enclave. AWS-certificaatbeheerder (ACM) voor Nitro Enclaves stelt u in staat openbare en privé SSL/TLS-certificaten te gebruiken met uw webapplicaties en servers die draaien op EC2-instanties met Nitro Enclaves.

U kunt deze functies van Nitro Enclaves gebruiken om de risico's die verband houden met PII- en PHI-gegevens te beperken. We raden aan Nitro Enclaves op te nemen in een LLM-service bij het verwerken van gevoelige gebruikersgegevens.

Overzicht oplossingen

Laten we de architectuur van de voorbeeldservice bekijken, nu inclusief Nitro Enclaves. Door Nitro Enclaves te integreren, zoals weergegeven in de volgende afbeelding, wordt de LLM een veiligere chatbot voor het verwerken van PHI- of PII-gegevens.

llm-met-aws-nitro-enclaves-diagram

Figuur 2 – Overzichtsdiagram oplossing

Gebruikersgegevens, inclusief PII, PHI en vragen, blijven gecodeerd tijdens het hele aanvraag-antwoordproces wanneer de applicatie binnen een enclave wordt gehost. De stappen die tijdens de gevolgtrekking worden uitgevoerd, zijn als volgt:

  1. De chatbot-app genereert tijdelijke AWS-inloggegevens en vraagt ​​de gebruiker een vraag in te voeren. De vraag, die PII of PHI kan bevatten, wordt vervolgens gecodeerd via AWS KMS. De gecodeerde gebruikersinvoer wordt gecombineerd met de tijdelijke inloggegevens om het gecodeerde verzoek te creëren.
  2. De gecodeerde gegevens worden als een POST-verzoek naar een HTTP-server verzonden die door Flask wordt gehost. Voordat gevoelige gegevens worden geaccepteerd, moet dit eindpunt worden geconfigureerd voor HTTPs.
  3. De client-app ontvangt het POST-verzoek en stuurt dit via een beveiligd lokaal kanaal (bijvoorbeeld vsock) door naar de server-app die in Nitro Enclaves draait.
  4. De Nitro Enclaves-serverapp gebruikt de tijdelijke inloggegevens om het verzoek te decoderen, de LLM op te vragen en het antwoord te genereren. De modelspecifieke instellingen worden opgeslagen in de enclaves en zijn beveiligd met cryptografisch attestatie.
  5. De server-app gebruikt dezelfde tijdelijke inloggegevens om het antwoord te coderen.
  6. Het gecodeerde antwoord wordt via de client-app teruggestuurd naar de chatbot-app als antwoord van het POST-verzoek.
  7. De chatbot-app decodeert het antwoord met behulp van hun KMS-sleutel en geeft de platte tekst weer aan de gebruiker.

Voorwaarden

Voordat we aan de slag gaan, heeft u de volgende vereisten nodig om de oplossing te implementeren:

Configureer een EC2-instantie

Voer de volgende stappen uit om een ​​EC2-instantie te configureren:

  1. Start een r5.8xgroot EC2-instantie met behulp van de amzn2-ami-kernel-5.10-hvm-2.0.20230628.0-x86_64-gp2 AMI met Nitro Enclaves ingeschakeld.
  2. Installeer de Nitro Enclaves CLI om Nitro Enclaves-applicaties te bouwen en uit te voeren:
    • sudo amazon-linux-extras install aws-nitro-enclaves-cli -y
    • sudo yum install aws-nitro-enclaves-cli-devel -y
  3. Controleer de installatie van de Nitro Enclaves CLI:
    • nitro-cli –version
    • De versie die in dit bericht wordt gebruikt is 1.2.2
  4. Installeer Git en Docker om Docker-images te bouwen en download de applicatie van GitHub. Voeg uw exemplaargebruiker toe aan de Docker-groep ( is uw IAM-instantiegebruiker):
    • sudo yum install git -y
    • sudo usermod -aG ne <USER>
    • sudo usermod -aG docker <USER>
    • sudo systemctl start docker && sudo systemctl enable docker
  5. Start en schakel de Nitro Enclaves-allocator- en vsock-proxyservices in:
    • sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
    • sudo systemctl start nitro-enclaves-vsock-proxy.service && sudo systemctl enable nitro-enclaves-vsock-proxy.service

Nitro Enclaves gebruikt een lokale socketverbinding genaamd vsock om een ​​veilig kanaal te creëren tussen de bovenliggende instantie en de enclave.

Nadat alle services zijn gestart en ingeschakeld, start u het exemplaar opnieuw op om te controleren of alle gebruikersgroepen en services correct werken:

sudo shutdown -r now

Configureer de Nitro Enclaves-allocatorservice

Nitro Enclaves is een geïsoleerde omgeving die een deel van de CPU en het geheugen van de instantie aanwijst om de enclave uit te voeren. Met de Nitro Enclaves Allocator-service kunt u aangeven hoeveel CPU's en hoeveel geheugen er van de bovenliggende instantie wordt afgenomen om de enclave uit te voeren.

Wijzig de gereserveerde bronnen van de enclave met behulp van een teksteditor (voor onze oplossing wijzen we 8 CPU's en 70,000 MiB-geheugen toe om voldoende bronnen te bieden):

vi /etc/nitro_enclaves/allocatory.yaml

AWS-Nitro-Enclaves-Allocator-Service-Config

Figuur 3 – AWS Nitro Enclaves Allocator-serviceconfiguratie

Kloon het project

Nadat u de EC2-instantie heeft geconfigureerd, kunt u de code downloaden om de gevoelige chatbot met een LLM in Nitro Enclaves uit te voeren.

U moet de server.py bestand met de juiste KMS-sleutel-ID die u in het begin hebt gemaakt om het LLM-antwoord te coderen.

  1. Kloon het GitHub-project:
    • cd ~/ && git clone https://<THE_REPO.git>
  2. Navigeer naar de projectmap om het enclave_base Docker-installatiekopie die de Nitro Enclaves softwareontwikkelingskit (SDK) voor cryptografische attestatiedocumenten van de Nitro Hypervisor (deze stap kan maximaal 15 minuten duren):
    • cd /nitro_llm/enclave_base
    • docker build ./ -t “enclave_base”

Sla de LLM op in de EC2-instantie

We gebruiken de open-source Bloom 560m LLM voor natuurlijke taalverwerking om reacties te genereren. Dit model is niet afgestemd op PII en PHI, maar laat zien hoe een LLM binnen een enclave kan leven. Het model moet ook op de bovenliggende instantie worden opgeslagen, zodat het via de Dockerfile naar de enclave kan worden gekopieerd.

  1. Navigeer naar het project:
    • cd /nitro_llm
  2. Installeer de noodzakelijke vereisten om het model lokaal op te slaan:
    • pip3 install requirements.txt
  3. Voer de ... uit save_model.py app om het model op te slaan binnen de /nitro_llm/enclave/bloom directory:
    • python3 save_model.py

Bouw en voer de Nitro Enclaves-image uit

Om Nitro Enclaves uit te voeren, moet u een enclave-imagebestand (EIF) maken op basis van een Docker-image van uw toepassing. Het Dockerfile in de enclave-map bevat de bestanden, code en LLM die binnen de enclave worden uitgevoerd.

Het bouwen en runnen van de enclave zal meerdere minuten in beslag nemen.

  1. Navigeer naar de hoofdmap van het project:
    • cd /nitro_llm
  2. Bouw het enclave-afbeeldingsbestand als enclave.eif:
    • nitro-cli build-enclave --docker-uri enclave:latest --output-file enclave.eif
AWS-Nitro-Enclave-Build-resultaat

Figuur 4 – Bouwresultaat van AWS Nitro Enclaves

Wanneer de enclave is gebouwd, wordt er een reeks unieke hashes en platformconfiguratieregisters (PCR's) gemaakt. De PCR's zijn een aaneengesloten meting om de identiteit van de hardware en applicatie te bewijzen. Deze PCR's zijn vereist voor cryptografische attestering en worden gebruikt tijdens de updatestap van het KMS-sleutelbeleid.

  1. Voer de enclave uit met de middelen uit de allocator.service (het toevoegen van de --attach-console argument aan het einde zal de enclave in debug-modus uitvoeren):
    • nitro-cli run-enclave --cpu-count 8 --memory 70000 --enclave-cid 16 --eif-path enclave.eif

U moet minimaal vier keer de EIF-bestandsgrootte toewijzen. Dit kan aangepast worden in de allocator.service uit eerdere stappen.

  1. Controleer of de enclave actief is met de volgende opdracht:
    • nitro-cli describe-enclaves
AWS-Nitro-Enclave-Beschrijf-Command-Response

Figuur 5 – AWS Nitro Enclave Beschrijf de opdracht

Update het KMS-sleutelbeleid

Voer de volgende stappen uit om uw KMS-sleutelbeleid bij te werken:

  1. Kies op de AWS KMS-console Door de klant beheerde sleutels in het navigatievenster.
  2. Zoek naar de sleutel die u als vereiste hebt gegenereerd.
  3. Kies Edit over het kernbeleid.
  4. Werk het sleutelbeleid bij met de volgende informatie:
    • Uw account-ID
    • Uw IAM-gebruikersnaam
    • De bijgewerkte rol van de Cloud9-omgevingsinstantie
    • Acties kms:Encrypt en kms:Decrypt
    • Voeg PCR's (bijvoorbeeld PCR0, PCR1, PCR2) toe aan uw sleutelbeleid met een voorwaardeverklaring

Zie de volgende belangrijke beleidscode:

{
   "Version":"2012-10-17",
   "Id":"key-default-1",
   "Statement":[
      {
         "Sid":"Enable User permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::user/"
         },
         "Action":[
            "kms:CreateAlias",
            "kms:CreateKey",
            "kms:DeleteAlias",
            "kms:Describe*",
            "kms:GenerateRandom",
            "kms:Get*",
            "kms:List*",
            "kms:TagResource",
            "kms:UntagResource",
            "iam:ListGroups",
            "iam:ListRoles",
            "iam:ListUsers"
         ],
         "Resource":"*"
      },
      {
         "Sid":"Enable Enclave permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::role/"
         },
         "Action":[
            "kms:Encrypt",
            "kms:Decrypt"
         ],
         "Resource":"*",
         "Condition":{
            "StringEqualsIgnoreCase":{
               "kms:RecipientAttestation:PCR0":"",
               "kms:RecipientAttestation:PCR1":"",
               "kms:RecipientAttestation:PCR2":""
            }
         }
      }
   ]
}

Sla de chatbot-app op

Om een ​​chatbottoepassing met gevoelige zoekopdrachten na te bootsen die buiten het AWS-account leeft, moet u de chatbot.py app en voer deze uit binnen de Cloud9-omgeving. Uw Cloud9-omgeving gebruikt de instantierol voor tijdelijke inloggegevens om de machtigingen los te koppelen van de EC2 die de enclave uitvoert. Voer de volgende stappen uit:

  1. Open op de Cloud9-console de omgeving die u hebt gemaakt.
  2. Kopieer de volgende code naar een nieuw bestand, bijvoorbeeld chatbot.py naar de hoofddirectory.
  3. Installeer de vereiste modules:
    • pip install boto3
    • Pip install requests
  4. Noteer op de Amazon EC2-console het IP-adres dat is gekoppeld aan uw Nitro Enclaves-exemplaar.
  5. Update de URL-variabele in http://<ec2instanceIP>:5001.
"""
Modules for a basic chatbot like application and AWS communications
"""
import base64
import requests
import boto3
 
def get_identity_document():
    """
    Get identity document for current EC2 Host
    """
    identity_doc = requests.get(
        "http://169.254.169.254/latest/dynamic/instance-identity/document", timeout=30)
    return identity_doc
 
def get_region(identity):
    """
    Get account of current instance identity
    """
    region = identity.json()["region"]
    return region
 
def get_account(identity):
    """
    Get account of current instance identity
    """
    account = identity.json()["accountId"]
    return account
 
def set_identity():
    """
    Set region and account for KMS
    """
    identity = get_identity_document()
    region = get_region(identity)
    account = get_account(identity)
    return region, account
 
def prepare_server_request(ciphertext):
    """
    Get the AWS credential from EC2 instance metadata
    """
    instance_prof = requests.get(
        "http://169.254.169.254/latest/meta-data/iam/security-credentials/", timeout=30)
    instance_profile_name = instance_prof.text
 
    instance_prof_json = requests.get(
        f"http://169.254.169.254/latest/meta-data/iam/security-credentials/{instance_profile_name}",
        timeout=30)
    response = instance_prof_json.json()
 
    credential = {
        'access_key_id': response['AccessKeyId'],
        'secret_access_key': response['SecretAccessKey'],
        'token': response['Token'],
        'region': REGION,
        'ciphertext': ciphertext
    }
    return credential
 
def get_user_input():
    """
    Start chatbot to collect user input
    """
    print("Chatbot: Hello! How can I assist you?")
    user_input = input('Your Question: ')
    return user_input.lower()
 
def encrypt_string(user_input, alias, kms):
    """
    Encrypt user input using AWS KMS
    """
    file_contents = user_input
    encrypted_file = kms.encrypt(KeyId=f'alias/{alias}', Plaintext=file_contents)
    encrypted_file_contents = encrypted_file[u'CiphertextBlob']
    encrypted_file_contents_base64 = base64.b64encode(encrypted_file_contents)
    return encrypted_file_contents_base64.decode()
 
def decrypt_data(encrypted_data, kms):
    """
    Decrypt the LLM response using AWS KMS
    """
    try:
        ciphertext_blob = base64.b64decode(encrypted_data)
        response = kms.decrypt(CiphertextBlob=ciphertext_blob)
        decrypted_data = response['Plaintext'].decode()
        return decrypted_data
    except ImportError as e_decrypt:
        print("Decryption failed:", e_decrypt)
        return None
 
REGION, ACCOUNT = set_identity()
  
def main():
    """
    Main function to encrypt/decrypt data and send/receive with parent instance
    """
    kms = boto3.client('kms', region_name=REGION)
    alias = "ncsnitro"
    user_input = get_user_input()
    encrypted_input = encrypt_string(user_input, alias, kms)
    server_request = prepare_server_request(encrypted_input)
    url = 'http://<EC2 Instance Private IP>:5001'
    x = requests.post(url, json = server_request)
    response_body = x.json()
    llm_response = decrypt_data(response_body["EncryptedData"], kms)
    print(llm_response)
 
if __name__ == '__main__':
    main()

  1. Voer de chatbot-applicatie uit:
    • python3 chat.py

Wanneer de terminal actief is, vraagt ​​de terminal om gebruikersinvoer en volgt hij het architecturale diagram van eerder om een ​​veilig antwoord te genereren.

Voer de privévraag uit en beantwoord de chatbot

Nu Nitro Enclaves actief is op de EC2-instantie, kunt u uw chatbot PHI- en PII-vragen veiliger stellen. Laten we eens kijken naar een voorbeeld.

Binnen de Cloud9-omgeving stellen we onze chatbot een vraag en geven we onze gebruikersnaam op.

vraag-kan-mijn-e-mail niet benaderen

Figuur 6 – De chatbot een vraag stellen

AWS KMS codeert de vraag, die eruitziet als de volgende schermafbeelding.

excrypted-vraag

Figuur 7 – Gecodeerde vraag

Vervolgens wordt het naar de enclave gestuurd en bij de beveiligde LLM opgevraagd. De vraag en het antwoord van de LLM zien er uit als in de volgende schermafbeelding (het resultaat en het gecodeerde antwoord zijn alleen zichtbaar in de enclave in de foutopsporingsmodus).

vraag-antwoord-van-llm

Figuur 8 – Reactie van LLM

Het resultaat wordt vervolgens gecodeerd met AWS KMS en teruggestuurd naar de Cloud9-omgeving om te worden gedecodeerd.

definitief gedecodeerd antwoord

Figuur 9 – Laatste gedecodeerde reactie

Opruimen

Voer de volgende stappen uit om uw bronnen op te schonen:

  1. Stop de EC2-instantie die is gemaakt om uw enclave te huisvesten.
  2. Verwijder de Cloud9-omgeving.
  3. Verwijder de KMS-sleutel.
  4. Verwijder de EC2-instantierol en IAM-gebruikersmachtigingen.

Conclusie

In dit bericht hebben we laten zien hoe u Nitro Enclaves kunt gebruiken om een ​​LLM-vraag- en antwoordservice in te zetten die veiliger PII- en PHI-informatie verzendt en ontvangt. Dit werd geïmplementeerd op Amazon EC2 en de enclaves zijn geïntegreerd met AWS KMS die de toegang tot een KMS-sleutel beperkt, zodat alleen Nitro Enclaves en de eindgebruiker de sleutel mogen gebruiken en de vraag kunnen decoderen.

Als u van plan bent deze architectuur te schalen om grotere werklasten te ondersteunen, zorg er dan voor dat het modelselectieproces overeenkomt met uw modelvereisten met EC2-resources. Bovendien moet u rekening houden met de maximale verzoekgrootte en welke impact dit zal hebben op de HTTP-server en de inferentietijd ten opzichte van het model. Veel van deze parameters kunnen worden aangepast via het model en de HTTP-serverinstellingen.

De beste manier om de specifieke instellingen en vereisten voor uw werklast te bepalen, is door te testen met een nauwkeurig afgestemde LLM. Hoewel dit bericht alleen natuurlijke taalverwerking van gevoelige gegevens omvatte, kunt u deze architectuur aanpassen om alternatieve LLM's te ondersteunen die audio, computervisie of multimodaliteiten ondersteunen. Dezelfde beveiligingsprincipes die hier worden benadrukt, kunnen worden toegepast op gegevens in elk formaat. De bronnen die zijn gebruikt om dit bericht te maken, zijn beschikbaar op de GitHub repo.

Deel in het opmerkingengedeelte hoe u deze oplossing gaat aanpassen aan uw omgeving.

Over de auteurs

Justin Miles is een cloudingenieur binnen de Leidos Digital Modernization Sector onder het Office of Technology. In zijn vrije tijd houdt hij van golfen en reizen.

Liv d'Aliberti is een onderzoeker binnen de Leidos AI/ML Accelerator onder het Office of Technology. Hun onderzoek richt zich op privacybeschermende machine learning.

Chris Renzo is een Sr. Solution Architect binnen de AWS Defense and Aerospace organisatie. Buiten zijn werk houdt hij van de balans tussen warm weer en reizen.

Joe Kovba is vice-president binnen de Leidos Digital Modernization Sector. In zijn vrije tijd houdt hij ervan om voetbalwedstrijden te scheidsrechteren en softbal te spelen.

spot_img

Laatste intelligentie

spot_img

Copyright @ 2024 Plato Technologies Inc.