Kecerdasan Data Generatif

AI

Inferensi model bahasa besar atas data rahasia menggunakan AWS Nitro Enclaves | Layanan Web Amazon

Diterbitkan ulang oleh Plato
Diterbitkan ulang oleh Plato

Tanggal:

views: 0

Postingan ini ditulis bersama Justin Miles, Liv d'Aliberti, dan Joe Kovba dari Leidos. 

Leidos adalah pemimpin solusi sains dan teknologi Fortune 500 yang bekerja untuk mengatasi beberapa tantangan terberat di dunia dalam pasar pertahanan, intelijen, keamanan dalam negeri, sipil, dan layanan kesehatan. Dalam postingan ini, kami membahas bagaimana Leidos bekerja dengan AWS untuk mengembangkan pendekatan terhadap inferensi model bahasa besar (LLM) yang menjaga privasi menggunakan Enklave AWS Nitro.

LLM dirancang untuk memahami dan menghasilkan bahasa mirip manusia, dan digunakan di banyak industri, termasuk pemerintahan, perawatan kesehatan, keuangan, dan kekayaan intelektual. LLM memiliki penerapan yang luas, termasuk chatbots, pembuatan konten, terjemahan bahasa, analisis sentimen, sistem penjawab pertanyaan, mesin pencari, dan pembuatan kode. Memperkenalkan inferensi berbasis LLM ke dalam sistem juga berpotensi menimbulkan ancaman privasi, termasuk eksfiltrasi model, pelanggaran privasi data, dan manipulasi layanan berbasis LLM yang tidak disengaja. Arsitektur teknis perlu diterapkan untuk memastikan bahwa LLM tidak memaparkan informasi sensitif selama inferensi.

Postingan ini membahas bagaimana Nitro Enclave dapat membantu melindungi penerapan model LLM, khususnya yang menggunakan informasi identitas pribadi (PII) atau informasi kesehatan yang dilindungi (PHI). Postingan ini hanya untuk tujuan pendidikan dan tidak boleh digunakan di lingkungan produksi tanpa kontrol tambahan.

Ikhtisar LLM dan Nitro Enclave

Kasus penggunaan potensial adalah chatbot kueri sensitif berbasis LLM yang dirancang untuk menjalankan layanan tanya jawab yang berisi PII dan PHI. Sebagian besar solusi chatbot LLM saat ini secara eksplisit memberi tahu pengguna bahwa mereka tidak boleh menyertakan PII atau PHI saat memasukkan pertanyaan karena masalah keamanan. Untuk memitigasi kekhawatiran ini dan melindungi data pelanggan, pemilik layanan terutama mengandalkan perlindungan pengguna seperti berikut:

  • Redaksi – Proses mengidentifikasi dan mengaburkan informasi sensitif seperti PII dalam dokumen, teks, atau bentuk konten lainnya. Hal ini dapat dicapai dengan memasukkan data sebelum dikirim ke model atau LLM yang dilatih untuk menyunting respons mereka secara otomatis.
  • Otentikasi multi-faktor – Proses keamanan yang mengharuskan pengguna menyediakan beberapa metode autentikasi untuk memverifikasi identitas mereka guna mendapatkan akses ke LLM.
  • Transport Layer Security (TLS) – Protokol kriptografi yang menyediakan komunikasi aman yang meningkatkan privasi data dalam transit antara pengguna dan layanan LLM.

Meskipun praktik ini meningkatkan postur keamanan layanan, namun hal ini tidak cukup untuk melindungi semua informasi sensitif pengguna dan informasi sensitif lainnya yang dapat disimpan tanpa sepengetahuan pengguna.

Dalam contoh kasus penggunaan kami, layanan LLM dirancang untuk menjawab pertanyaan tunjangan kesehatan karyawan atau menyediakan program pensiun pribadi. Mari kita menganalisis contoh arsitektur berikut dan mengidentifikasi area risiko privasi data.

llm-diagram area risiko

Gambar 1 – Diagram Area Risiko Privasi Data

Area risiko potensial adalah sebagai berikut:

  1. Pengguna yang memiliki hak istimewa memiliki akses ke instance yang menampung server. Perubahan yang tidak disengaja atau tidak sah pada layanan dapat mengakibatkan data sensitif terekspos dengan cara yang tidak diinginkan.
  2. Pengguna harus percaya bahwa layanan tidak akan mengekspos atau menyimpan informasi sensitif dalam log aplikasi.
  3. Perubahan pada paket aplikasi dapat menyebabkan perubahan pada layanan, yang mengakibatkan terbukanya data sensitif.
  4. Pengguna yang memiliki hak istimewa dengan akses ke instans memiliki akses tidak terbatas ke LLM yang digunakan oleh layanan. Perubahan dapat menyebabkan informasi yang salah atau tidak akurat dikembalikan kepada pengguna.

Nitro Enclaves memberikan isolasi tambahan untuk Anda Cloud komputasi elastis Amazon (Amazon EC2), melindungi data yang digunakan dari akses tidak sah, termasuk pengguna tingkat admin. Dalam arsitektur sebelumnya, perubahan yang tidak disengaja mungkin saja mengakibatkan data sensitif tetap berada dalam teks biasa dan secara tidak sengaja terungkap kepada pengguna yang mungkin tidak perlu mengakses data tersebut. Dengan Nitro Enclave, Anda membuat lingkungan terisolasi dari instans EC2, memungkinkan Anda mengalokasikan sumber daya CPU dan memori ke enclave. Daerah kantong ini adalah mesin virtual yang sangat membatasi. Dengan menjalankan kode yang menangani data sensitif dalam enklave, tidak ada proses induk yang dapat melihat data enklave.

Nitro Enclaves menawarkan manfaat berikut:

  • Isolasi Memori dan CPU – Ini bergantung pada Nitro Hypervisor untuk mengisolasi CPU dan memori enclave dari pengguna, aplikasi, dan perpustakaan pada instans induk. Fitur ini membantu mengisolasi enclave dan perangkat lunak Anda, dan secara signifikan mengurangi luas permukaan untuk kejadian yang tidak diinginkan.
  • Mesin virtual terpisah – Enclave adalah mesin virtual terpisah yang terpasang pada instans EC2 untuk lebih melindungi dan memproses data yang sangat sensitif dengan aman.
  • Tidak ada akses interaktif – Enclave hanya menyediakan konektivitas soket lokal yang aman dengan instance induknya. Mereka tidak memiliki penyimpanan persisten, akses interaktif, atau jaringan eksternal.
  • Pengesahan kriptografi – Penawaran Nitro Enklave pengesahan kriptografi, sebuah proses yang digunakan untuk membuktikan identitas enklave dan memverifikasi bahwa hanya kode resmi yang berjalan di enklave Anda.
  • Integrasi AWS – Nitro Enclave terintegrasi dengan Layanan Manajemen Kunci AWS (AWS KMS), memungkinkan Anda mendekripsi file yang telah dienkripsi menggunakan AWS KMS di dalam enklave. Manajer Sertifikat AWS (ACM) untuk Nitro Enclave memungkinkan Anda menggunakan sertifikat SSL/TLS publik dan privat dengan aplikasi web dan server Anda yang berjalan pada instans EC2 dengan Nitro Enclave.

Anda dapat menggunakan fitur-fitur yang disediakan oleh Nitro Enclaves untuk membantu memitigasi risiko yang terkait dengan data PII dan PHI. Kami merekomendasikan untuk menyertakan Nitro Enclave dalam layanan LLM saat menangani data pengguna yang sensitif.

Ikhtisar solusi

Mari kita periksa arsitektur layanan contoh, yang sekarang termasuk Nitro Enclaves. Dengan menggabungkan Nitro Enclaves, seperti yang ditunjukkan pada gambar berikut, LLM menjadi chatbot yang lebih aman untuk menangani data PHI atau PII.

llm-menggunakan-aws-nitro-enklave-diagram

Gambar 2 – Diagram Ikhtisar Solusi

Data pengguna, termasuk PII, PHI, dan pertanyaan, tetap terenkripsi selama proses permintaan-respons saat aplikasi dihosting dalam enclave. Langkah-langkah yang dilakukan pada saat inferensi adalah sebagai berikut:

  1. Aplikasi chatbot menghasilkan kredensial AWS sementara dan meminta pengguna untuk memasukkan pertanyaan. Pertanyaannya, yang mungkin berisi PII atau PHI, kemudian dienkripsi melalui AWS KMS. Input pengguna terenkripsi digabungkan dengan kredensial sementara untuk membuat permintaan terenkripsi.
  2. Data terenkripsi dikirim ke server HTTP yang dihosting oleh Flask sebagai permintaan POST. Sebelum menerima data sensitif, titik akhir ini harus dikonfigurasi untuk HTTP.
  3. Aplikasi klien menerima permintaan POST dan meneruskannya melalui saluran lokal yang aman (misalnya, vsock) ke aplikasi server yang berjalan di dalam Nitro Enclaves.
  4. Aplikasi server Nitro Enclaves menggunakan kredensial sementara untuk mendekripsi permintaan, menanyakan LLM, dan menghasilkan respons. Pengaturan khusus model disimpan di dalam enklave dan dilindungi dengan pengesahan kriptografi.
  5. Aplikasi server menggunakan kredensial sementara yang sama untuk mengenkripsi respons.
  6. Respons terenkripsi dikembalikan ke aplikasi chatbot melalui aplikasi klien sebagai respons dari permintaan POST.
  7. Aplikasi chatbot mendekripsi respons menggunakan kunci KMS dan menampilkan teks biasa kepada pengguna.

Prasyarat

Sebelum memulai, Anda memerlukan prasyarat berikut untuk menerapkan solusi:

Konfigurasikan instans EC2

Selesaikan langkah-langkah berikut untuk mengonfigurasi instans EC2:

  1. Luncurkan r5.8xbesar Instans EC2 menggunakan amzn2-ami-kernel-5.10-hvm-2.0.20230628.0-x86_64-gp2 AMI dengan Nitro Enklave diaktifkan.
  2. Instal Nitro Enclaves CLI untuk membangun dan menjalankan aplikasi Nitro Enclaves:
    • sudo amazon-linux-extras install aws-nitro-enclaves-cli -y
    • sudo yum install aws-nitro-enclaves-cli-devel -y
  3. Verifikasi instalasi Nitro Enclaves CLI:
    • nitro-cli –version
    • Versi yang digunakan dalam postingan ini adalah 1.2.2
  4. Instal Git dan Docker untuk membuat image Docker dan unduh aplikasi dari GitHub. Tambahkan pengguna instans Anda ke grup Docker ( adalah pengguna instans IAM Anda):
    • sudo yum install git -y
    • sudo usermod -aG ne <USER>
    • sudo usermod -aG docker <USER>
    • sudo systemctl start docker && sudo systemctl enable docker
  5. Mulai dan aktifkan layanan pengalokasi Nitro Enclaves dan proxy vsock:
    • 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 Enclave menggunakan koneksi soket lokal yang disebut vsock untuk membuat saluran aman antara instance induk dan enclave.

Setelah semua layanan dimulai dan diaktifkan, mulai ulang instance untuk memverifikasi bahwa semua grup pengguna dan layanan berjalan dengan benar:

sudo shutdown -r now

Konfigurasikan layanan pengalokasi Nitro Enclaves

Nitro Enclave adalah lingkungan terisolasi yang menetapkan sebagian CPU dan memori instance untuk menjalankan enclave. Dengan layanan pengalokasi Nitro Enclaves, Anda dapat menunjukkan berapa banyak CPU dan berapa banyak memori yang akan diambil dari instance induk untuk menjalankan enclave.

Ubah sumber daya cadangan enklave menggunakan editor teks (untuk solusi kami, kami mengalokasikan 8 CPU dan 70,000 MiB memori untuk menyediakan sumber daya yang cukup):

vi /etc/nitro_enclaves/allocatory.yaml

AWS-Nitro-Enclaves-Allocator-Service-Config

Gambar 3 – Konfigurasi Layanan Pengalokasi AWS Nitro Enclaves

Mengkloning proyek

Setelah Anda mengonfigurasi instans EC2, Anda dapat mengunduh kode untuk menjalankan chatbot sensitif dengan LLM di dalam Nitro Enclaves.

Anda perlu memperbarui server.py file dengan ID kunci KMS sesuai yang Anda buat di awal untuk mengenkripsi respons LLM.

  1. Kloning proyek GitHub:
    • cd ~/ && git clone https://<THE_REPO.git>
  2. Arahkan ke folder proyek untuk membangun enclave_base Gambar Docker yang berisi Kit Pengembangan Perangkat Lunak Nitro Enclave (SDK) untuk dokumen pengesahan kriptografi dari Nitro Hypervisor (langkah ini dapat memakan waktu hingga 15 menit):
    • cd /nitro_llm/enclave_base
    • docker build ./ -t “enclave_base”

Simpan LLM di Instans EC2

Kami menggunakan Bloom 560m LLM sumber terbuka untuk pemrosesan bahasa alami guna menghasilkan tanggapan. Model ini tidak disesuaikan dengan PII dan PHI, namun menunjukkan bagaimana LLM dapat hidup di dalam enklave. Model juga perlu disimpan pada instance induk agar dapat disalin ke enclave melalui Dockerfile.

  1. Navigasi ke proyek:
    • cd /nitro_llm
  2. Instal persyaratan yang diperlukan untuk menyimpan model secara lokal:
    • pip3 install requirements.txt
  3. Jalankan save_model.py aplikasi untuk menyimpan model di dalamnya /nitro_llm/enclave/bloom direktori:
    • python3 save_model.py

Bangun dan jalankan image Nitro Enclaves

Untuk menjalankan Nitro Enclaves, Anda perlu membuat file image enclave (EIF) dari image Docker aplikasi Anda. Dockerfile yang terletak di direktori enclave berisi file, kode, dan LLM yang akan dijalankan di dalam enclave.

Membangun dan menjalankan enklave akan memakan waktu beberapa menit untuk menyelesaikannya.

  1. Arahkan ke akar proyek:
    • cd /nitro_llm
  2. Bangun file gambar enklave sebagai enclave.eif:
    • nitro-cli build-enclave --docker-uri enclave:latest --output-file enclave.eif
Hasil Pembuatan AWS-Nitro-Enclave

Gambar 4 – Hasil Pembuatan AWS Nitro Enclaves

Ketika enclave dibangun, serangkaian hash unik dan register konfigurasi platform (PCR) akan dibuat. PCR adalah pengukuran yang berdekatan untuk membuktikan identitas perangkat keras dan aplikasi. PCR ini akan diperlukan untuk pengesahan kriptografi dan digunakan selama langkah pembaruan kebijakan kunci KMS.

  1. Jalankan enklave dengan sumber daya dari allocator.service (menambahkan --attach-console argumen di akhir akan menjalankan enklave dalam mode debug):
    • nitro-cli run-enclave --cpu-count 8 --memory 70000 --enclave-cid 16 --eif-path enclave.eif

Anda perlu mengalokasikan setidaknya empat kali ukuran file EIF. Ini dapat dimodifikasi di allocator.service dari langkah sebelumnya.

  1. Verifikasi enklave berjalan dengan perintah berikut:
    • nitro-cli describe-enclaves
AWS-Nitro-Enclave-Describe-Command-Respons

Gambar 5 – Perintah Penjelasan AWS Nitro Enclave

Perbarui kebijakan kunci KMS

Selesaikan langkah-langkah berikut untuk memperbarui kebijakan kunci KMS Anda:

  1. Di konsol AWS KMS, pilih Kunci yang dikelola pelanggan di panel navigasi.
  2. Cari kunci yang Anda buat sebagai prasyarat.
  3. Pilih Edit pada kebijakan utama.
  4. Perbarui kebijakan utama dengan informasi berikut:
    • ID akun Anda
    • Nama pengguna IAM Anda
    • Peran instans lingkungan Cloud9 yang diperbarui
    • tindakan kms:Encrypt dan kms:Decrypt
    • Enklave PCR (misalnya, PCR0, PCR1, PCR2) ke kebijakan kunci Anda dengan pernyataan kondisi

Lihat kode kebijakan utama berikut:

{
   "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":""
            }
         }
      }
   ]
}

Simpan aplikasi chatbot

Untuk meniru aplikasi chatbot kueri sensitif yang berada di luar akun AWS, Anda perlu menyimpan chatbot.py aplikasi dan jalankan di dalam lingkungan Cloud9. Lingkungan Cloud9 Anda akan menggunakan peran instansnya untuk kredensial sementara guna memisahkan izin dari EC2 yang menjalankan enclave. Selesaikan langkah-langkah berikut:

  1. Di konsol Cloud9, buka lingkungan yang Anda buat.
  2. Salin kode berikut ke dalam file baru seperti chatbot.py ke dalam direktori utama.
  3. Instal modul yang diperlukan:
    • pip install boto3
    • Pip install requests
  4. Di konsol Amazon EC2, catat IP yang terkait dengan instans Nitro Enclave Anda.
  5. Perbarui variabel URL di 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. Jalankan aplikasi chatbot:
    • python3 chat.py

Saat berjalan, terminal akan meminta masukan pengguna dan mengikuti diagram arsitektur dari sebelumnya untuk menghasilkan respons yang aman.

Jalankan chatbot tanya jawab pribadi

Sekarang setelah Nitro Enclaves aktif dan berjalan pada instans EC2, Anda dapat mengajukan pertanyaan PHI dan PII pada chatbot Anda dengan lebih aman. Mari kita lihat sebuah contoh.

Dalam lingkungan Cloud9, kami mengajukan pertanyaan kepada chatbot kami dan memberikan nama pengguna kami.

pertanyaan-tidak-dapat-mengakses-email-saya

Gambar 6 – Mengajukan Pertanyaan pada Bot Obrolan

AWS KMS mengenkripsi pertanyaan, yang terlihat seperti tangkapan layar berikut.

pertanyaan terenkripsi

Gambar 7 – Pertanyaan Terenkripsi

Kemudian dikirim ke enclave dan diminta ke LLM yang diamankan. Pertanyaan dan tanggapan LLM akan terlihat seperti tangkapan layar berikut (hasil dan tanggapan terenkripsi hanya terlihat di dalam enklave dalam mode debug).

pertanyaan-jawaban-dari-llm

Gambar 8 – Tanggapan dari LLM

Hasilnya kemudian dienkripsi menggunakan AWS KMS dan dikembalikan ke lingkungan Cloud9 untuk didekripsi.

respons-dekripsi-akhir

Gambar 9 – Respon Dekripsi Akhir

Membersihkan

Selesaikan langkah-langkah berikut untuk membersihkan sumber daya Anda:

  1. Hentikan instans EC2 yang dibuat untuk menampung enclave Anda.
  2. Hapus lingkungan Cloud9.
  3. Hapus kunci KMS.
  4. Hapus peran instans EC2 dan izin pengguna IAM.

Kesimpulan

Dalam postingan ini, kami menunjukkan cara menggunakan Nitro Enclaves untuk menerapkan layanan tanya jawab LLM yang mengirim dan menerima informasi PII dan PHI dengan lebih aman. Ini diterapkan di Amazon EC2, dan enklave tersebut terintegrasi dengan AWS KMS yang membatasi akses ke kunci KMS, sehingga hanya Nitro Enclave dan pengguna akhir yang diizinkan untuk menggunakan kunci tersebut dan mendekripsi pertanyaan.

Jika Anda berencana untuk menskalakan arsitektur ini untuk mendukung beban kerja yang lebih besar, pastikan proses pemilihan model sesuai dengan persyaratan model Anda dengan sumber daya EC2. Selain itu, Anda harus mempertimbangkan ukuran permintaan maksimum dan dampaknya terhadap server HTTP serta waktu inferensi terhadap model. Banyak dari parameter ini dapat disesuaikan melalui model dan pengaturan server HTTP.

Cara terbaik untuk menentukan pengaturan dan persyaratan spesifik untuk beban kerja Anda adalah melalui pengujian dengan LLM yang disesuaikan. Meskipun postingan ini hanya menyertakan pemrosesan bahasa alami untuk data sensitif, Anda dapat memodifikasi arsitektur ini untuk mendukung LLM alternatif yang mendukung audio, visi komputer, atau multi-modalitas. Prinsip keamanan yang sama yang disoroti di sini dapat diterapkan pada data dalam format apa pun. Sumber daya yang digunakan untuk membuat postingan ini tersedia di GitHub repo.

Bagikan bagaimana Anda akan mengadaptasi solusi ini untuk lingkungan Anda di bagian komentar.

Tentang Penulis

Justin Miles adalah insinyur cloud di Sektor Modernisasi Digital Leidos di bawah Kantor Teknologi. Di waktu luangnya, dia menikmati bermain golf dan jalan-jalan.

Liv d'Aliberti adalah seorang peneliti dalam Akselerator AI/ML Leidos di bawah Kantor Teknologi. Penelitian mereka berfokus pada pembelajaran mesin yang menjaga privasi.

Chris Renzo adalah Sr. Solution Architect dalam organisasi AWS Defense and Aerospace. Di luar pekerjaan, dia menikmati keseimbangan antara cuaca hangat dan perjalanan.

Joe Kovba adalah Wakil Presiden di Sektor Modernisasi Digital Leidos. Di waktu luangnya, dia menikmati menjadi wasit pertandingan sepak bola dan bermain softball.

tempat_img

Intelijen Terbaru

tempat_img

Hak Cipta @ 2024 Plato Technologies Inc.