See on ühine postitus, mille on kaasa kirjutanud Leidos ja AWS. Leidos on FORTUNE 500 teadus- ja tehnoloogialahenduste liider, kes töötab selle nimel, et lahendada mõned maailma raskeimatest väljakutsetest kaitse-, luure-, sisejulgeoleku-, tsiviil- ja tervishoiuturgudel.

Leidos on teinud koostööd AWS-iga, et töötada välja lähenemisviis privaatsust säilitavale, konfidentsiaalsele masinõppe (ML) modelleerimisele, mille käigus saate luua pilve toega krüptitud torujuhtmeid.

Homomorfne krüptimine on uus lähenemine krüpteerimisele, mis võimaldab arvutusi ja analüütilisi funktsioone käivitada krüptitud andmetel, ilma et peaksite neid eelnevalt dekrüpteerima, et säilitada privaatsus juhtudel, kui teil on eeskirjad, mille kohaselt ei tohi andmeid kunagi dekrüpteerida. Täielikult homomorfne krüptimine (FHE) on seda tüüpi lähenemisviisi tugevaim idee ja see võimaldab teil oma andmete väärtust avada, kui usaldusväärsus on null. Põhinõue on see, et andmeid peab olema võimalik esitada numbritega kodeerimistehnika abil, mida saab rakendada numbriliste, tekstiliste ja pildipõhiste andmekogumite jaoks. FHE-d kasutavad andmed on suuremad, seega tuleb testida rakendusi, mis vajavad peaaegu reaalajas või suurusepiirangutega järeldusi. Samuti on oluline sõnastada kõik arvutused lineaarsete võrranditena.

Selles postituses näitame, kuidas aktiveerida kõige rangemalt reguleeritud keskkondades privaatsust säilitavaid ML-ennustusi. Ennustused (järeldused) kasutavad krüptitud andmeid ja tulemused dekrüpteerib ainult lõpptarbija (kliendipool).

Selle demonstreerimiseks näitame näidet an kohandamise kohta Amazon SageMaker Scikit-learn avatud lähtekoodiga süvaõppe konteiner et võimaldada juurutatud lõpp-punktil kliendipoolseid krüptitud järeldustaotlusi vastu võtta. Kuigi see näide näitab, kuidas seda järeldustoimingute jaoks teha, saate lahendust laiendada koolitusele ja muudele ML-i etappidele.

Lõpp-punktid juurutatakse paari klõpsu või koodireaga, kasutades SageMakerit, mis lihtsustab arendajate ja ML-ekspertide jaoks pilves ML-i ja süvaõppe mudelite loomist ja koolitamist. SageMakeri abil loodud mudeleid saab seejärel kasutusele võtta kui reaalajas lõpp-punktid, mis on kriitilise tähtsusega järelduste töökoormuste jaoks, kus teil on reaalajas, püsiseisundi ja madala latentsusaja nõuded. Rakendused ja teenused saavad helistada juurutatud lõpp-punktile otse või juurutatud serverita Amazon API värav arhitektuur. Lisateavet reaalajas lõpp-punkti arhitektuuri parimate tavade kohta leiate aadressilt Masinõppepõhise REST API loomine Amazon API Gateway kaardistusmallide ja Amazon SageMakeriga. Järgmisel joonisel on näidatud nende mustrite mõlemad versioonid.

Mõlema mustri puhul tagab edastamisel olev krüptimine konfidentsiaalsuse, kuna andmed liiguvad teenuste kaudu järeldustoimingu tegemiseks. Kui SageMakeri lõpp-punkt võtab vastu, dekrüpteeritakse andmed tavaliselt käitusajal järeldustoimingu tegemiseks ning need pole välistele koodidele ja protsessidele juurdepääsetavad. Täiendava kaitsetaseme saavutamiseks võimaldab FHE järeldustoimingul genereerida krüptitud tulemusi, mille tulemused saab usaldusväärse rakenduse või kliendi poolt dekrüpteerida.

Lisateavet täielikult homomorfse krüptimise kohta

FHE võimaldab süsteemidel teostada arvutusi krüptitud andmete põhjal. Saadud arvutused on dekrüpteerimisel kontrollitavalt lähedased ilma krüpteerimisprotsessita tehtud arvutustele. FHE võib arvutusse sisestatud müra tõttu põhjustada väikese matemaatilise ebatäpsuse, mis sarnaneb ujukoma veaga. Seda juhitakse sobivate FHE krüpteerimisparameetrite valimisega, mis on probleemispetsiifiline häälestatud parameeter. Lisateabe saamiseks vaadake videot Kuidas seletaksite homomorfset krüptimist?

Järgmisel diagrammil on toodud FHE-süsteemi rakendamise näide.

Selles süsteemis saate teie või teie usaldusväärne klient teha järgmist.

1. Krüptige andmed avaliku võtme FHE skeemi abil. On paar erinevat vastuvõetavat skeemi; selles näites kasutame CKKS-skeemi. Lisateavet meie valitud FHE avaliku võtmega krüpteerimisprotsessi kohta leiate artiklist CKKS selgitas.
2. Saatke kliendipoolsed krüptitud andmed teenusepakkujale või serverile töötlemiseks.
3. Tehke krüpteeritud andmete põhjal mudeli järeldusi; FHE-ga pole dekrüpteerimist vaja.
4. Krüptitud tulemused tagastatakse helistajale ja seejärel dekrüpteeritakse, et paljastada teie tulemus, kasutades privaatvõtit, mis on saadaval ainult teile või teie kliendi usaldusväärsetele kasutajatele.

Oleme SageMakeri lõpp-punkte kasutava näite loomiseks kasutanud eelmist arhitektuuri, Pyfhel FHE API ümbrisena, mis lihtsustab integreerimist ML-rakendustega ja SEAL meie aluseks oleva FHE krüptimise tööriistakomplektina.

Lahenduse ülevaade

Oleme koostanud AWS-is skaleeritava FHE-konveieri näite, kasutades SKÕppige logistilist regressiooni süvaõppe konteiner koos Iirise andmestik. Teostame andmete uurimist ja funktsioonide kavandamist SageMakeri sülearvuti abil ning seejärel teostame mudelikoolitust, kasutades a SageMakeri koolitustöö. Saadud mudel on lähetatud SageMakeri reaalajas lõpp-punktile klienditeeninduste jaoks kasutamiseks, nagu on näidatud järgmisel diagrammil.

Selles arhitektuuris näeb krüptimata andmeid ainult klientrakendus. Mudeli kaudu järelduste tegemiseks töödeldud andmed jäävad kogu selle elutsükli vältel krüpteerituks, isegi isoleeritud protsessori tööajal. AWS Nitro Enklaav. Järgmistes jaotistes käime läbi selle torujuhtme ehitamise koodi.

Eeldused

Järgimiseks eeldame, et olete käivitanud a SageMakeri märkmik koos AWS-i identiteedi- ja juurdepääsuhaldus (IAM) rolli koos AmazonSageMakerFullAccess juhitud poliitika.

Treeni modelli

Järgmine diagramm illustreerib mudelkoolituse töövoogu.

Järgmine kood näitab, kuidas me valmistame esmalt ette andmed SageMakeri sülearvutite abil treenimiseks, tõmbades sisse oma treeninguandmestiku, tehes vajalikud puhastustoimingud ja laadides seejärel andmed üles Amazoni lihtne salvestusteenus (Amazon S3) kopp. Selles etapis peate võib-olla tegema oma andmestiku täiendavaid funktsioone või integreerima erinevate võrguühenduseta funktsioonide poodidega.

# Setup/Train Logistic Regression Estimator # load and preprocess iris dataset
iris = datasets.load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
target_df = pd.DataFrame(data=iris.target, columns=["species"])
iris_df = (iris_df - iris_df.mean(0)) / (iris_df.std(0)) # save iris dataset
iris_df = pd.concat([iris_df, target_df], axis=1)
fname = "iris.csv"
iris_df.to_csv(fname, index=False) # upload dataset to S3
bucket = Session().default_bucket()
upload _path = f"training data/fhe train.csv"
boto3.Session().resource("s3").Bucket (bucket) .Object (upload path).upload file(fname)

Selles näites kasutame skriptirežiim SageMakeri algselt toetatud raamistikul (skikit õppima), kus me loome oma SageMaker SKLearn vaikehinnangu kohandatud treeningskriptiga, et käsitleda krüptitud andmeid järelduste tegemisel. Lisateabe saamiseks natiivselt toetatud raamistike ja skriptirežiimi kohta vaadake Kasutage koos Amazon SageMakeriga masinõppe raamistikke, Pythonit ja R-i.

# instantiate estimator
sklearn estimator = SKLearn( role=get_execution_ role(), entry point="fhe train.py", source_dir="fhe_files", instance_type="ml.c4.xlarge" framework version="0.23-1",
)

Lõpuks koolitame oma mudelit andmestikule ja juurutame koolitatud mudeli meie valitud eksemplaritüübile.

# fit the model
sklearn estimator.fit("s3://" + bucket + "/training data") # construct predictor from trained model
predictor = sklearn_estimator.deploy(instance_type="ml.c4.xlarge", initial_instance_count=1)

Praeguseks oleme välja õpetanud kohandatud SKLearn FHE mudeli ja juurutanud selle SageMakeri reaalajas järelduste lõpp-punktis, mis on valmis krüptitud andmete vastuvõtmiseks.

Krüpteerige ja saatke kliendi andmed

Järgmine diagramm illustreerib kliendiandmete krüptimise ja mudelisse saatmise töövoogu.

Enamikul juhtudel sisaldab järelduse lõpp-punkti kõne kasulik koormus krüptitud andmeid, mitte ei salvesta neid esmalt Amazon S3-sse. Teeme seda selles näites, kuna oleme järelduskutseks koondanud suure hulga kirjeid. Praktikas on see partii suurus väiksem või kasutatakse selle asemel partii teisendust. Amazon S3 kasutamine vahendajana ei ole FHE jaoks vajalik.

Nüüd, kui järelduse lõpp-punkt on seadistatud, saame alustada andmete saatmist. Tavaliselt kasutame erinevaid katse- ja treeningandmekogumeid, kuid selle näite puhul kasutame sama treeningu andmestikku.

Esiteks laadime kliendi poolel Irise andmestiku. Järgmisena seadistasime Pyfheli abil FHE konteksti. Valisime selle protsessi jaoks Pyfheli, kuna seda on lihtne installida ja sellega töötada, see sisaldab populaarseid FHE-skeeme ja tugineb usaldusväärsele avatud lähtekoodiga krüptimise juurutamisele. SEAL. Selles näites saadame krüptitud andmed koos selle FHE skeemi avalike võtmete teabega serverisse, mis võimaldab lõpp-punktil krüptida tulemuse, et saata see enda poolele vajalike FHE parameetritega, kuid ei anna sellele võimalus sissetulevaid andmeid dekrüpteerida. Privaatvõti jääb ainult kliendile, kellel on võimalus tulemusi dekrüpteerida.

# Encrypt Data Locally # load and preprocess potentially private data
iris = datasets.load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
target_df = pd.DataFrame(data=iris.target, columns=["species"])
iris_df = (iris_df - iris_df.mean(0)) / (iris_df.std(0)) # setup FHE
HE = Pyfhel()
ckks_params = { “scheme”: "CKKS", "n": 2 ** 14, "scale": 2 ** 30, "qi_sizes": [60, 30, 30, 30, 60],
}
HE.contextGen(**ckks_params)
HE.keyGen()
HE.relinKeyGen()
HE.rotateKeyGen() # encrypt the data
iris_np = np.append( iris_df.to_numpy(), np.ones((len(iris_df), 1)), -1 # append 1 for bias term
)
encrypted_iris = [HE.encryptFrac(row).to_bytes() for row in iris np]

Pärast andmete krüptimist koostame täieliku andmesõnastiku – sealhulgas asjakohased võtmed ja krüptitud andmed –, mis salvestatakse Amazon S3-sse. Edaspidi teeb mudel oma ennustused kliendi krüptitud andmete põhjal, nagu on näidatud järgmises koodis. Pange tähele, et me ei edasta privaatvõtit, mistõttu mudeli host ei saa andmeid dekrüpteerida. Selles näites edastame andmed S3 objektina; Teise võimalusena võib need andmed saata otse Sagemakeri lõpp-punkti. Reaalajas lõpp-punktina sisaldab kasulik koormus päringu kehas olevat andmeparameetrit, mida mainitakse SageMakeri dokumentatsioon.

# Send data to get prediction # store data and encryption paramters
data dict = { "data": encrypted_iris, "public_key": HE.to_bytes_public_key(), "relin_key": HE.to_bytes_relin key(), "rotate_key": HE.to_bytes_rotate_key(), "context": HE.to_bytes_context(),
} # upload data and encryption parameters to s3
pickle.dump(data_dict, open("request.pkl”, "wb"))
boto3.Session().resource("s3").Bucket(bucket).Object("request.pkl").upload_file("request.pkl") # get predictions from our instance
response = predictor.predict({ "bucket": bucket, "uri": "request.pkl"})
predictions = pickle.loads(response)

Järgmine ekraanipilt näitab keskmist ennustust fhe_train.py (lisas on kogu koolituse skript).

predictions = []
for data in encrypted_data: encrypted_prediction = [ HE.scalar_prod_plain(data, encoded_coef, in_new_ctxt=True).to_bytes() for encoded_coef in encoded_coefs ] predictions.append(encrypted_prediction)

Arvutame välja oma krüptitud logistilise regressiooni tulemused. See kood arvutab iga võimaliku klassi jaoks krüptitud skalaartoote ja tagastab tulemused kliendile. Tulemused on prognoositud logid iga klassi jaoks kõigis näidetes.

Klient tagastab dekrüpteeritud tulemused

Järgmine diagramm illustreerib kliendi töövoogu, mis toob oma krüptitud tulemuse ja dekrüpteerib selle (privaatvõtmega, millele ainult neil on juurdepääs), et paljastada järelduse tulemus.

Selles näites salvestatakse tulemused Amazon S3-sse, kuid üldiselt tagastatakse need reaalajas lõpp-punkti kasuliku koormuse kaudu. Amazon S3 kasutamine vahendajana ei ole FHE jaoks vajalik.

Järeldustulemus on kontrollitavalt lähedal tulemustele, nagu oleksid nad selle ise arvutanud, ilma FHE-d kasutamata.

# Decrypt results locally # extract predictions from class probabilities
cl_preds = []
for prediction in predictions: logits = [PyCtxt(bytestring=p, scheme="CKKS", pyfhel=HE) for p in prediction] cl = np.argmax([HE.decryptFrac(logit)[0] for logit in logits]) c1_preds.append(cl) # compute accuracy
np.mean(cl_preds == target_df.to_numpy().squeeze()) * 100 # clean up
predictor.delete_endpoint()

Koristage

Lõpetame selle protsessi, kustutades loodud lõpp-punkti, veendumaks, et pärast seda protsessi ei jääks kasutamata arvutusi.

Tulemused ja kaalutlused

FHE mudelite peal kasutamise üks levinumaid puudusi on see, et see lisab arvutuslikke üldkulusid, mis praktikas muudab tulemuseks oleva mudeli interaktiivsete kasutusjuhtude jaoks liiga aeglaseks. Kuid juhtudel, kui andmed on väga tundlikud, võib olla kasulik nõustuda selle latentsusaja kompromissiga. Kuid meie lihtsa logistilise regressiooni jaoks suudame 140 sekundi jooksul töödelda 60 sisendandmete näidist ja näha lineaarset jõudlust. Järgmine diagramm sisaldab lõpp-lõpuni koguaega, sealhulgas aega, mille klient sisendi krüpteerimiseks ja tulemuste dekrüpteerimiseks kulub. Samuti kasutab see Amazon S3, mis lisab latentsust ja pole nendel juhtudel vajalik.

Näidete arvu suurendamisel 1-lt 150-le näeme lineaarset skaleerimist. See on ootuspärane, kuna iga näide krüpteeritakse üksteisest sõltumatult, seega eeldame arvutuste lineaarset suurenemist fikseeritud häälestuskuludega.

See tähendab ka seda, et saate SageMakeri lõpp-punkti taga suurema päringu läbilaskevõime saavutamiseks oma järeldusparki skaleerida horisontaalselt. Sa võid kasutada Amazon SageMakeri järelduste soovitus kulude optimeerimiseks vastavalt teie ettevõtte vajadustele.

Järeldus

Ja see ongi käes: täielikult homomorfse krüptimise ML SKLearni logistilise regressioonimudeli jaoks, mille saate seadistada mõne koodireaga. Teatud kohandamisega saate seda sama krüpteerimisprotsessi rakendada erinevate mudelitüüpide ja raamistike jaoks, sõltumata koolitusandmetest.

Kui soovite saada lisateavet homomorfset krüptimist kasutava ML-lahenduse loomise kohta, võtke lisateabe saamiseks ühendust oma AWS-i kontomeeskonna või partneri Leidosega. Rohkemate näidete saamiseks võite vaadata ka järgmisi ressursse.

Selle postituse sisu ja arvamused sisaldavad kolmandate osapoolte autorite arvamusi ja AWS ei vastuta selle postituse sisu ega täpsuse eest.

Lisa

Täielik koolitusskript on järgmine:

import argparse
import os
import pickle
from io import BytesIO import boto3
import joblib
import numpy as np
import pandas as pd
from Pyfhel import PyCtxt, Pyfhel
from sklearn.linear_model import LogisticRegression def model_fn(model_dir): clf = joblib.load(os.path.join(model_dir, "model.joblib")) return clf def input_fn(request_body, request_content_type): loaded_data = np.load(BytesIO(request_body), allow_pickle=True).item() boto3.Session().resource("s3").Bucket(loaded_data["bucket"]).download_file( loaded_data["uri"], "request.pkl" ) loaded_data = pickle.load(open("request.pkl", "rb")) return loaded_data def predict_fn(input_data, model): HE = Pyfhel() data = input_data["data"] HE.from_bytes_context(input_data["context"]) HE.from_bytes_public_key(input_data["public_key"]) HE.from_bytes_relin_key(input_data["relin_key"]) HE.from_bytes_rotate_key(input_data["rotate_key"]) encrypted_data = [PyCtxt(bytestring=row, scheme="CKKS", pyfhel=HE) for row in data] coefs = [ np.append(coef, intercept).astype("float64") for coef, intercept in zip(model.coef_, model.intercept_) ] encoded_coefs = [HE.encodeFrac(coef) for coef in coefs] predictions = [] for data in encrypted_data: encrypted_prediction = [ HE.scalar_prod_plain(data, encoded_coef, in_new_ctxt=True).to_bytes() for encoded_coef in encoded_coefs ] predictions.append(encrypted_prediction) encoded_output = pickle.dumps(predictions) output = np.frombuffer(encoded_output, dtype="byte") return output if __name__ == "__main__": parser = argparse.ArgumentParser() # Data and model directories parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR")) parser.add_argument( "--train", type=str, default=os.environ.get("SM_CHANNEL_TRAINING") ) args, _ = parser.parse_known_args() train_df = pd.read_csv(args.train + "/" + "fhe_train.csv") model = LogisticRegression() model.fit(train_df.iloc[:, :-1], train_df.iloc[:, -1]) acc = np.mean(model.predict(train_df.iloc[:, :-1]) == train_df.iloc[:, -1]) * 100 print("****Accuracy****", acc) joblib.dump(model, os.path.join(args.model_dir, "model.joblib"))

Autoritest

Liv d'Aliberti on teadur Tehnoloogiabüroo Leidose AI/ML Acceleratoris. Nende uurimistöö keskendub privaatsust säilitavale masinõppele.

Manbir Gulati on Tehnoloogiabüroo Leidose AI/ML Acceleratori teadur. Tema uurimistöö keskendub küberjulgeoleku ja tekkivate tehisintellekti ohtude ristumiskohale.

Joe Kovba on pilvekeskuse tippkeskuse praktikajuht Leidose digitaalse moderniseerimise kiirendis, mis kuulub Tehnoloogiaameti alla. Vabal ajal naudib ta jalgpallimängude kohtunikuna ja softballi mängimisega.

Ben Snively on avaliku sektori spetsialist lahenduste arhitekt. Ta töötab valitsusasutuste, mittetulundusühingute ja haridusasutuste klientidega suurandmete ja analüütiliste projektide kallal, aidates neil luua lahendusi AWS-i abil. Vabal ajal lisab ta kogu oma maja IoT andureid ja teeb nende põhjal analüüsi.

Sami Hoda on ülemaailmset avalikku sektorit hõlmava Partners Consulting osakonna vanemlahenduste arhitekt. Sami on kirglik projektide vastu, kus võrdsetes osades disainimõtlemist, innovatsiooni ja emotsionaalset intelligentsust saab kasutada abivajavate inimeste probleemide lahendamiseks ja mõjutamiseks.

• SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
• Platoblockchain. Web3 metaversiooni intelligentsus. Täiustatud teadmised. Juurdepääs siia.
• Allikas: https://aws.amazon.com/blogs/machine-learning/enable-fully-homomorphic-encryption-with-amazon-sagemaker-endpoints-for-secure-real-time-inferencing/