Kunstig intelligens (AI) har blitt et viktig og populært tema i teknologimiljøet. Etter hvert som AI har utviklet seg, har vi sett forskjellige typer maskinlæringsmodeller (ML) dukke opp. En tilnærming, kjent som ensemble modellering, har raskt fått gjennomslag blant dataforskere og praktikere. I dette innlegget diskuterer vi hva ensemblemodeller er og hvorfor bruken av dem kan være fordelaktig. Vi gir deretter et eksempel på hvordan du kan trene, optimalisere og distribuere dine tilpassede ensembler ved hjelp av Amazon SageMaker.
Ensemblelæring refererer til bruken av flere læringsmodeller og algoritmer for å oppnå mer nøyaktige spådommer enn noen enkelt, individuell læringsalgoritme. De har vist seg å være effektive i ulike applikasjoner og læringsinnstillinger som nettsikkerhet [1] og svindeldeteksjon, fjernmåling, forutsi beste neste trinn i økonomisk beslutningstaking, medisinsk diagnose, og til og med datasyn og naturlig språkbehandling (NLP) oppgaver. Vi har en tendens til å kategorisere ensembler etter teknikkene som brukes for å trene dem, deres komposisjon og måten de slår sammen de forskjellige spådommene til en enkelt slutning. Disse kategoriene inkluderer:
- Styrking – Trene sekvensielt flere svake elever, der hver feil prediksjon fra tidligere elever i sekvensen gis høyere vekt og input til neste elev, og dermed skape en sterkere elev. Eksempler inkluderer AdaBoost, Gradient Boosting og XGBoost.
- bagging – Bruker flere modeller for å redusere variansen til en enkelt modell. Eksempler inkluderer Random Forest og Extra Trees.
- Stabling (blanding) – Bruker ofte heterogene modeller, der prediksjoner av hver enkelt estimator stables sammen og brukes som input til en endelig estimator som håndterer prediksjonen. Denne endelige estimatorens opplæringsprosess bruker ofte kryssvalidering.
Det er flere metoder for å kombinere spådommene til den eneste som modellen til slutt produserer, for eksempel ved å bruke en meta-estimator som lineær elev, en stemmemetode som bruker flere modeller for å lage en prediksjon basert på flertallsstemmegivning for klassifiseringsoppgaver, eller et ensemble som tar gjennomsnitt for regresjon.
Selv om flere biblioteker og rammeverk gir implementeringer av ensemblemodeller, som XGBoost, CatBoost eller scikit-learns tilfeldige skog, fokuserer vi i dette innlegget på å ta med dine egne modeller og bruke dem som et stableensemble. Men i stedet for å bruke dedikerte ressurser for hver modell (dedikerte opplærings- og tuningjobber og hosting-endepunkter per modell), trener, tuner og distribuerer vi et tilpasset ensemble (flere modeller) ved å bruke en enkelt SageMaker-treningsjobb og en enkelt tuningjobb, og distribuerer til et enkelt endepunkt, og reduserer dermed mulige kostnader og driftskostnader.
BYOE: Ta med ditt eget ensemble
Det er flere måter å trene og distribuere heterogene ensemblemodeller med SageMaker: du kan trene hver modell i en egen treningsjobb og optimaliser hver modell separat ved å bruke Amazon SageMaker Automatisk modellinnstilling. Når du er vert for disse modellene, tilbyr SageMaker ulike kostnadseffektive måter å være vert for flere modeller på samme leietakerinfrastruktur. Du finner detaljerte distribusjonsmønstre for denne typen innstillinger i Modellvertsmønstre i Amazon SageMaker, del 1: Vanlige designmønstre for å bygge ML-applikasjoner på Amazon SageMaker. Disse mønstrene inkluderer bruk av flere endepunkter (for hver trent modell) eller ett enkelt multi-modell endepunkt, eller til og med en singel endepunkt for flere beholdere hvor beholderne kan påkalles individuelt eller lenkes i en rørledning. Alle disse løsningene inkluderer en meta-estimator (for eksempel i en AWS Lambda funksjon) som påkaller hver modell og implementerer blandings- eller stemmefunksjonen.
Men å kjøre flere treningsjobber kan føre til drifts- og kostnadsoverhead, spesielt hvis ensemblet ditt krever opplæring på samme data. På samme måte krever det å være vert for forskjellige modeller på separate endepunkter eller beholdere og kombinere deres prediksjonsresultater for bedre nøyaktighet, og derfor introduserer ytterligere administrasjons-, kostnads- og overvåkingsinnsats. SageMaker støtter for eksempel ensemble ML-modeller ved hjelp av Triton Inference Server, men denne løsningen krever at modellene eller modellensemblene støttes av Triton-backend. I tillegg kreves det ekstra innsats fra kunden for å sette opp Triton-serveren og ytterligere læring for å forstå hvordan forskjellige Triton-backends fungerer. Derfor foretrekker kunder en mer enkel måte å implementere løsninger der de bare trenger å sende invokasjonen én gang til endepunktet og har fleksibiliteten til å kontrollere hvordan resultatene aggregeres for å generere det endelige resultatet.
Løsningsoversikt
For å løse disse bekymringene går vi gjennom et eksempel på ensembletrening ved å bruke en enkelt treningsjobb, optimalisere modellens hyperparametre og distribuere den ved hjelp av en enkelt beholder til et serverløst endepunkt. Vi bruker to modeller for ensemblestabelen vår: CatBoost og XGBoost (som begge er forsterkende ensembler). For våre data bruker vi diabetes datasett [2] fra scikit-learn-biblioteket: Den består av 10 funksjoner (alder, kjønn, kroppsmasse, blodtrykk og seks blodserummålinger), og vår modell forutsier sykdomsprogresjonen 1 år etter grunnlinjefunksjonene ble samlet inn (en regresjonsmodell).
Hele kodelageret finner du på GitHub.
Tren flere modeller i en enkelt SageMaker-jobb
For opplæring av modellene våre bruker vi SageMaker opplæringsjobber i skriptmodus. Med skriptmodus kan du skrive tilpasset opplæring (og senere slutningskode) mens du bruker SageMaker-rammebeholdere. Rammebeholdere lar deg bruke ferdige miljøer administrert av AWS som inkluderer all nødvendig konfigurasjon og moduler. For å demonstrere hvordan du kan tilpasse en rammebeholder, som et eksempel, bruker vi den forhåndsbygde SKLearn-beholderen, som ikke inkluderer XGBoost- og CatBoost-pakkene. Det er to alternativer for å legge til disse pakkene: enten forleng den innebygde beholderen for å installere CatBoost og XGBoost (og deretter distribuere som en tilpasset beholder), eller bruk SageMaker treningsjobbskriptmodus-funksjonen, som lar deg tilby en requirements.txt
fil når du oppretter treningsberegningen. SageMaker-opplæringsjobben installerer de listede bibliotekene i requirements.txt
fil under kjøretiden. På denne måten trenger du ikke å administrere ditt eget Docker-bildelager, og det gir mer fleksibilitet til å kjøre treningsskript som trenger ytterligere Python-pakker.
Følgende kodeblokk viser koden vi bruker for å starte treningen. De entry_point
parameter peker på treningsskriptet vårt. Vi bruker også to av SageMaker SDK API sine overbevisende funksjoner:
- Først spesifiserer vi den lokale banen til kildekatalogen vår og avhengigheter i
source_dir
ogdependencies
parametere, henholdsvis. SDK-en vil komprimere og laste opp disse katalogene til Amazon enkel lagringstjeneste (Amazon S3) og SageMaker vil gjøre dem tilgjengelige på treningsforekomsten under arbeidskatalogen/opt/ml/code
. - For det andre bruker vi SDK
SKLearn
estimator-objekt med vår foretrukne Python- og rammeversjon, slik at SageMaker vil trekke den tilsvarende beholderen. Vi har også definert en egendefinert treningsberegning 'validation:rmse
', som sendes ut i treningsloggene og fanges opp av SageMaker. Senere bruker vi denne metrikken som den objektive metrikken i tuning-jobben.
hyperparameters = {"num_round": 6, "max_depth": 5}
estimator_parameters = {
"entry_point": "multi_model_hpo.py",
"source_dir": "code",
"dependencies": ["my_custom_library"],
"instance_type": training_instance_type,
"instance_count": 1,
"hyperparameters": hyperparameters,
"role": role,
"base_job_name": "xgboost-model",
"framework_version": "1.0-1",
"keep_alive_period_in_seconds": 60,
"metric_definitions":[
{'Name': 'validation:rmse', 'Regex': 'validation-rmse:(.*?);'}
]
}
estimator = SKLearn(**estimator_parameters)
Deretter skriver vi treningsskriptet vårt (multi_model_hpo.py). Skriptet vårt følger en enkel flyt: fange opp hyperparametre som jobben ble konfigurert med og trene CatBoost-modellen og XGBoost -modell. Vi implementerer også en k-fold kryss valideringsfunksjon. Se følgende kode:
if __name__ == "__main__":
parser = argparse.ArgumentParser() # Sagemaker specific arguments. Defaults are set in the environment variables.
parser.add_argument("--output-data-dir", type=str, default=os.environ["SM_OUTPUT_DATA_DIR"])
parser.add_argument("--model-dir", type=str, default=os.environ["SM_MODEL_DIR"])
parser.add_argument("--train", type=str, default=os.environ["SM_CHANNEL_TRAIN"])
parser.add_argument("--validation", type=str, default=os.environ["SM_CHANNEL_VALIDATION"])
.
.
.
"""
Train catboost
"""
K = args.k_fold
catboost_hyperparameters = {
"max_depth": args.max_depth,
"eta": args.eta,
}
rmse_list, model_catboost = cross_validation_catboost(train_df, K, catboost_hyperparameters)
.
.
.
"""
Train the XGBoost model
""" hyperparameters = {
"max_depth": args.max_depth,
"eta": args.eta,
"objective": args.objective,
"num_round": args.num_round,
} rmse_list, model_xgb = cross_validation(train_df, K, hyperparameters)
Etter at modellene er trent, beregner vi gjennomsnittet av både CatBoost- og XGBoost-spådommene. Resultatet, pred_mean
, er vårt ensembles endelige spådom. Deretter bestemmer vi mean_squared_error
mot valideringssettet. val_rmse
brukes til evaluering av hele ensemblet under trening. Legg merke til at vi også skriver ut RMSE-verdien i et mønster som passer til regex vi brukte i metric_definitions
. Senere vil SageMaker Automatic Model Tuning bruke det til å fange den objektive metrikken. Se følgende kode:
pred_mean = np.mean(np.array([pred_catboost, pred_xgb]), axis=0)
val_rmse = mean_squared_error(y_validation, pred_mean, squared=False)
print(f"Final evaluation result: validation-rmse:{val_rmse}")
Til slutt lagrer skriptet vårt begge modellartefakter til utdatamappen som ligger på /opt/ml/model
.
Når en opplæringsjobb er fullført, pakker og kopierer SageMaker innholdet i /opt/ml/model
katalogen som et enkelt objekt i komprimert TAR-format til S3-plasseringen som du spesifiserte i jobbkonfigurasjonen. I vårt tilfelle samler SageMaker de to modellene i en TAR-fil og laster den opp til Amazon S3 på slutten av treningsjobben. Se følgende kode:
model_file_name = 'catboost-regressor-model.dump'
# Save CatBoost model
path = os.path.join(args.model_dir, model_file_name)
print('saving model file to {}'.format(path))
model.save_model(path)
.
.
.
# Save XGBoost model
model_location = args.model_dir + "/xgboost-model"
pickle.dump(model, open(model_location, "wb"))
logging.info("Stored trained model at {}".format(model_location))
Oppsummert bør du legge merke til at i denne prosedyren lastet vi ned dataene én gang og trente to modeller ved å bruke en enkelt treningsjobb.
Automatisk innstilling av ensemblemodeller
Fordi vi bygger en samling av ML-modeller, er det upraktisk å utforske alle mulige hyperparameter-permutasjoner. SageMaker tilbyr Automatisk modellinnstilling (AMT), som ser etter de beste modellhyperparametrene ved å fokusere på de mest lovende kombinasjonene av verdier innenfor områder du angir (det er opp til deg å definere de riktige områdene å utforske). SageMaker støtter flere optimaliseringsmetoder for deg å velge fra.
Vi starter med å definere de to delene av optimaliseringsprosessen: den objektive metrikken og hyperparametrene vi ønsker å justere. I vårt eksempel bruker vi validerings-RMSE som målberegning og vi tuner eta
og max_depth
(for andre hyperparametre, se XGBoost hyperparametere og CatBoost hyperparametre):
from sagemaker.tuner import (
IntegerParameter,
ContinuousParameter,
HyperparameterTuner,
) hyperparameter_ranges = {
"eta": ContinuousParameter(0.2, 0.3),
"max_depth": IntegerParameter(3, 4)
}
metric_definitions = [{"Name": "validation:rmse", "Regex": "validation-rmse:([0-9.]+)"}]
objective_metric_name = "validation:rmse"
Vi må også sørge for i treningsmanus at hyperparametrene våre ikke er hardkodet og hentes fra SageMaker kjøretidsargumenter:
catboost_hyperparameters = {
"max_depth": args.max_depth,
"eta": args.eta,
}
SageMaker skriver også hyperparametrene til en JSON-fil og kan leses fra /opt/ml/input/config/hyperparameters.json
på treningsinstansen.
I likhet med CatBoost, fanger vi også opp hyperparametrene for XGBoost-modellen (legg merke til at objective
og num_round
er ikke innstilt):
catboost_hyperparameters = {
"max_depth": args.max_depth,
"eta": args.eta,
}
Til slutt starter vi hyperparameterinnstillingsjobben ved å bruke disse konfigurasjonene:
tuner = HyperparameterTuner(
estimator,
objective_metric_name,
hyperparameter_ranges,
max_jobs=4,
max_parallel_jobs=2,
objective_type='Minimize'
)
tuner.fit({"train": train_location, "validation": validation_location}, include_cls_metadata=False)
Når jobben er fullført, kan du hente verdiene for den beste treningsjobben (med minimal RMSE):
job_name=tuner.latest_tuning_job.name
attached_tuner = HyperparameterTuner.attach(job_name)
attached_tuner.describe()["BestTrainingJob"]
For mer informasjon om AMT, se Utfør automatisk modellinnstilling med SageMaker.
Utplassering
For å distribuere det tilpassede ensemblet vårt, må vi gi et skript for å håndtere slutningsforespørselen og konfigurere SageMaker-hosting. I dette eksemplet brukte vi en enkelt fil som inkluderer både opplærings- og slutningskoden (multi_model_hpo.py). SageMaker bruker koden under if _ name _ == "_ main _"
for treningen og funksjonene model_fn
, input_fn
og predict_fn
når du distribuerer og betjener modellen.
Inferensskript
Som med trening bruker vi SageMaker SKLearn-rammebeholderen med vårt eget inferensskript. Skriptet vil implementere tre metoder som kreves av SageMaker.
Først model_fn
metoden leser våre lagrede modellartefaktfiler og laster dem inn i minnet. I vårt tilfelle returnerer metoden vårt ensemble som all_model
, som er en Python-liste, men du kan også bruke en ordbok med modellnavn som nøkler.
def model_fn(model_dir):
catboost_model = CatBoostRegressor()
catboost_model.load_model(os.path.join(model_dir, model_file_name))
model_file = "xgboost-model"
model = pickle.load(open(os.path.join(model_dir, model_file), "rb"))
all_model = [catboost_model, model]
return all_model
Det andre, input_fn
metoden deserialiserer forespørselsdataene som skal sendes til vår slutningsbehandler. For mer informasjon om inndatabehandlere, se Tilpasning av din egen inferensbeholder.
def input_fn(input_data, content_type):
dtype=None
payload = StringIO(input_data)
return np.genfromtxt(payload, dtype=dtype, delimiter=",")
Tredje, predict_fn
metoden er ansvarlig for å få spådommer fra modellene. Metoden tar modellen og dataene som returneres fra input_fn
som parametere og returnerer den endelige prediksjonen. I vårt eksempel får vi CatBoost-resultatet fra modelllistens første medlem (model[0]
) og XGBoost fra det andre medlemmet (model[1]
), og vi bruker en blandingsfunksjon som returnerer gjennomsnittet av begge spådommene:
def predict_fn(input_data, model):
predictions_catb = model[0].predict(input_data)
dtest = xgb.DMatrix(input_data)
predictions_xgb = model[1].predict(dtest,
ntree_limit=getattr(model, "best_ntree_limit", 0),
validate_features=False)
return np.mean(np.array([predictions_catb, predictions_xgb]), axis=0)
Nå som vi har våre trente modeller og inferensskript, kan vi konfigurere miljøet til å distribuere ensemblet vårt.
SageMaker Serverless Inference
Selv om det er mange hostingalternativer i SageMaker, i dette eksemplet bruker vi et serverløst endepunkt. Serverløse endepunkter starter automatisk dataressurser og skalerer dem inn og ut avhengig av trafikk. Dette tar bort de udifferensierte tunge løftene ved å administrere servere. Dette alternativet er ideelt for arbeidsbelastninger som har inaktive perioder mellom trafikksprut og som tåler kaldstart.
Konfigurering av det serverløse endepunktet er enkelt fordi vi ikke trenger å velge forekomsttyper eller administrere skaleringspolicyer. Vi trenger bare å gi to parametere: minnestørrelse og maksimal samtidighet. Det serverløse endepunktet tildeler automatisk dataressurser proporsjonalt med minnet du velger. Hvis du velger en større minnestørrelse, har beholderen tilgang til flere vCPUer. Du bør alltid velge endepunktets minnestørrelse i henhold til modellstørrelsen. Den andre parameteren vi må gi er maksimal samtidighet. For et enkelt endepunkt kan denne parameteren settes opp til 200 (i skrivende stund er grensen for totalt antall serverløse endepunkter i en region 50). Du bør merke deg at den maksimale samtidigheten for et individuelt endepunkt hindrer det endepunktet i å ta opp alle påkallingene som er tillatt for kontoen din, fordi alle endepunktanrop utover maksimumet blir begrenset (for mer informasjon om den totale samtidigheten for alle serverløse endepunkter per region, se Amazon SageMaker endepunkter og kvoter).
from sagemaker.serverless.serverless_inference_config import ServerlessInferenceConfig
serverless_config = ServerlessInferenceConfig(
memory_size_in_mb=6144,
max_concurrency=1,
)
Nå som vi konfigurerte endepunktet, kan vi endelig distribuere modellen som ble valgt i vår hyperparameteroptimaliseringsjobb:
estimator=attached_tuner.best_estimator()
predictor = estimator.deploy(serverless_inference_config=serverless_config)
Rydd opp
Selv om serverløse endepunkter har null kostnader når de ikke brukes, når du er ferdig med å kjøre dette eksemplet, bør du sørge for å slette endepunktet:
predictor.delete_endpoint(predictor.endpoint)
konklusjonen
I dette innlegget dekket vi én tilnærming for å trene, optimalisere og distribuere et tilpasset ensemble. Vi detaljerte prosessen med å bruke en enkelt treningsjobb for å trene flere modeller, hvordan du bruker automatisk modellinnstilling for å optimalisere ensemblehyperparametrene, og hvordan du distribuerer et enkelt serverløst endepunkt som blander slutningene fra flere modeller.
Bruk av denne metoden løser potensielle kostnader og driftsproblemer. Kostnaden for en treningsjobb er basert på ressursene du bruker i løpet av bruken. Ved å laste ned dataene kun én gang for opplæring av de to modellene, reduserte vi med halvparten jobbens datanedlastingsfase og det brukte volumet som lagrer dataene, og reduserte dermed treningsjobbens totale kostnad. Videre kjørte AMT-jobben fire treningsjobber, hver med den nevnte reduserte tid og lagring, så det representerer 4 ganger kostnadsbesparelse! Når det gjelder modelldistribusjon på et serverløst endepunkt, fordi du også betaler for mengden data som behandles, betaler du halvparten av I/O-datakostnadene ved å påkalle endepunktet én gang for to modeller.
Selv om dette innlegget bare viste fordelene med to modeller, kan du bruke denne metoden til å trene, stille inn og distribuere en rekke ensemblemodeller for å se en enda større effekt.
Referanser
[1] Raj Kumar, P. Arun; Selvakumar, S. (2011). "Distribuert denial of service-angrepsdeteksjon ved bruk av et ensemble av nevrale klassifiserer". Datakommunikasjon. 34 (11): 1328–1341. doi:10.1016/j.comcom.2011.01.012.
[2] Bradley Efron, Trevor Hastie, Iain Johnstone og Robert Tibshirani (2004) "Least Angle Regression," Annals of Statistics (med diskusjon), 407-499. (https://web.stanford.edu/~hastie/Papers/LARS/LeastAngle_2002.pdf)
Om forfatterne
Melanie Li, PhD, er en senior AI/ML-spesialist TAM ved AWS med base i Sydney, Australia. Hun hjelper bedriftskunder med å bygge løsninger som utnytter de nyeste AI/ML-verktøyene på AWS og gir veiledning om arkitektur og implementering av maskinlæringsløsninger med beste praksis. På fritiden elsker hun å utforske naturen utendørs og tilbringe tid med familie og venner.
Uri Rosenberg er AI & ML Specialist Technical Manager for Europa, Midtøsten og Afrika. Basert fra Israel jobber Uri for å gi bedriftskunder mulighet til å designe, bygge og drive ML-arbeidsmengder i stor skala. På fritiden liker han å sykle, gå på fotturer og minimere RMSE.
- SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
- PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
- PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
- PlatoESG. Bil / elbiler, Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
- BlockOffsets. Modernisering av eierskap for miljøkompensasjon. Tilgang her.
- kilde: https://aws.amazon.com/blogs/machine-learning/efficiently-train-tune-and-deploy-custom-ensembles-using-amazon-sagemaker/
- : har
- :er
- :ikke
- :hvor
- ][s
- $OPP
- 1
- 10
- 100
- 11
- 200
- 2011
- 50
- 60
- 7
- a
- Om oss
- adgang
- Ifølge
- Logg inn
- nøyaktighet
- nøyaktig
- legge til
- Ytterligere
- I tillegg
- adresse
- afrika
- Etter
- mot
- alder
- AI
- AI / ML
- algoritme
- algoritmer
- Alle
- tillatt
- tillater
- også
- alltid
- Amazon
- Amazon SageMaker
- Amazon Web Services
- blant
- beløp
- an
- og
- noen
- søknader
- tilnærming
- ER
- argumenter
- AS
- At
- angripe
- Australia
- Automatisk
- automatisk
- tilgjengelig
- gjennomsnitt
- borte
- AWS
- Backend
- basert
- Baseline
- BE
- fordi
- bli
- vært
- være
- gunstig
- Fordeler
- BEST
- beste praksis
- Bedre
- mellom
- Beyond
- blending
- blander
- Blokker
- blod
- Blood Pressure
- kroppen
- øke
- både
- bringe
- Bringe
- bygge
- Bygning
- innebygd
- bunter
- men
- by
- beregne
- CAN
- fangst
- fanget
- saken
- kategorier
- Lenket
- avgifter
- Velg
- klassifisering
- kode
- forkjølelse
- samling
- kombinasjoner
- kombinere
- Felles
- kommunikasjon
- samfunnet
- overbevisende
- fullføre
- Beregn
- datamaskin
- Datamaskin syn
- bekymringer
- Konfigurasjon
- konfigurert
- består
- Container
- Containere
- innhold
- kontroll
- Tilsvarende
- Kostnad
- kostnadseffektiv
- dekket
- Opprette
- skikk
- kunde
- Kunder
- tilpasse
- Cybersecurity
- dato
- Beslutningstaking
- dedikert
- mislighold
- definere
- definert
- definere
- demonstrere
- Denial of Service
- avhengig
- utplassere
- utplasserings
- distribusjon
- utforming
- designmønstre
- detaljert
- Gjenkjenning
- Bestem
- forskjellig
- kataloger
- diskutere
- diskusjon
- sykdom
- diverse
- Docker
- ikke
- ikke
- nedlasting
- dumpe
- varighet
- under
- hver enkelt
- øst
- effekt
- effektiv
- effektivt
- innsats
- enten
- dukke
- bemyndige
- muliggjøre
- slutt
- Endpoint
- sikre
- Enterprise
- Miljø
- miljøer
- spesielt
- Europa
- evaluering
- Selv
- utviklet seg
- eksempel
- eksempler
- utforske
- Utforske
- ekstra
- familie
- Trekk
- Egenskaper
- filet
- Filer
- slutt~~POS=TRUNC
- Endelig
- finansiell
- Først
- fleksibilitet
- flyten
- Fokus
- fokusering
- etter
- følger
- Til
- skog
- format
- funnet
- fire
- Rammeverk
- rammer
- svindel
- svindeloppdagelse
- venner
- fra
- fullt
- funksjon
- funksjoner
- Dess
- Gevinst
- få
- generere
- få
- få
- gitt
- større
- veiledning
- Halvparten
- håndtere
- Håndterer
- Ha
- he
- tung
- tung løfting
- hjelper
- her
- høyere
- hans
- vert
- Hosting
- Hvordan
- Hvordan
- Men
- HTML
- http
- HTTPS
- Optimalisering av hyperparameter
- Innstilling av hyperparameter
- ideell
- Idle
- if
- bilde
- iverksette
- implementere
- redskaper
- viktig
- in
- inkludere
- inkluderer
- individuelt
- individuelt
- informasjon
- Infrastruktur
- inngang
- installere
- f.eks
- i stedet
- Intelligens
- inn
- introdusere
- Introduserer
- påkalt
- påkaller
- Israel
- saker
- IT
- Jobb
- Jobb
- jpg
- JSON
- nøkler
- Type
- kjent
- Språk
- større
- seinere
- lansere
- læring
- utnytte
- Li
- bibliotekene
- Bibliotek
- løfte
- BEGRENSE
- Liste
- oppført
- laster
- lokal
- ligger
- plassering
- logging
- UTSEENDE
- elsker
- maskin
- maskinlæring
- Hoved
- Flertall
- gjøre
- administrer
- fikk til
- ledelse
- leder
- administrerende
- Mass
- maksimal
- bety
- målinger
- medisinsk
- medlem
- Minne
- Flett
- metode
- metoder
- metrisk
- Middle
- Midtøsten
- kunne
- minimal
- minimere
- ML
- Mote
- modell
- modeller
- Moduler
- overvåking
- mer
- mest
- flere
- navn
- navn
- Naturlig
- Natural Language Processing
- Natur
- nødvendig
- Trenger
- neste
- nlp
- Legge merke til..
- Antall
- mange
- objekt
- Målet
- of
- Tilbud
- ofte
- on
- gang
- ONE
- bare
- betjene
- operasjonell
- optimalisering
- Optimalisere
- optimalisere
- Alternativ
- alternativer
- or
- OS
- Annen
- vår
- ut
- utendørs
- produksjon
- samlet
- egen
- pakker
- parameter
- parametere
- del
- deler
- bestått
- banen
- Mønster
- mønstre
- Betale
- for
- perioder
- fase
- rørledning
- plato
- Platon Data Intelligence
- PlatonData
- poeng
- Politikk
- Populær
- mulig
- Post
- potensiell
- praksis
- forutsi
- prediksjon
- Spådommer
- Predictor
- spår
- trekker
- trekkes
- press
- forhindrer
- forrige
- Skrive ut
- prosedyren
- prosess
- Bearbeidet
- prosessering
- produsere
- progresjon
- lovende
- utprøvd
- gi
- gir
- Python
- tilfeldig
- raskt
- Lese
- redusere
- Redusert
- redusere
- refererer
- betrakte
- regex
- region
- fjernkontroll
- Repository
- representere
- anmode
- påkrevd
- Krever
- Ressurser
- henholdsvis
- ansvarlig
- resultere
- Resultater
- retur
- avkastning
- ikke sant
- ROBERT
- Rolle
- Kjør
- rennende
- s
- sagemaker
- SageMaker Automatisk modellinnstilling
- samme
- Spar
- besparende
- Skala
- skalering
- forskere
- scikit lære
- skript
- SDK
- Sekund
- se
- sett
- valgt
- send
- senior
- separat
- Sequence
- Serum
- server~~POS=TRUNC
- Servere
- tjeneste
- Tjenester
- servering
- sett
- innstillinger
- flere
- Kjønn
- hun
- bør
- viste
- Viser
- på samme måte
- Enkelt
- enkelt
- SIX
- Størrelse
- So
- løsning
- Solutions
- løser
- kilde
- spesialist
- spesifikk
- spesifisert
- bruke
- stable
- stablet
- stabling
- stanford
- Begynn
- starter
- state-of-the-art
- statistikk
- Steps
- lagring
- lagret
- butikker
- rett fram
- sterkere
- slik
- SAMMENDRAG
- Støttes
- Støtter
- sikker
- sydney
- tar
- ta
- Target
- oppgaver
- Teknisk
- teknikker
- Teknologi
- leietaker
- enn
- Det
- De
- deres
- Dem
- deretter
- Der.
- derved
- derfor
- Disse
- de
- denne
- De
- selv om?
- tre
- Gjennom
- tid
- ganger
- til
- sammen
- verktøy
- Tema
- Totalt
- trekkraft
- trafikk
- Tog
- trent
- Kurs
- Trær
- Trevor
- Triton
- to
- typer
- etter
- forstå
- bruk
- bruke
- brukt
- bruker
- ved hjelp av
- validering
- verdi
- Verdier
- ulike
- versjon
- syn
- volum
- Stemmegivning
- ønsker
- var
- Vei..
- måter
- we
- web
- webtjenester
- vekt
- var
- Hva
- når
- hvilken
- mens
- hele
- hvorfor
- vil
- med
- innenfor
- Arbeid
- arbeid
- virker
- skrive
- skriving
- Xgboost
- år
- Du
- Din
- zephyrnet
- null