Effektivisering av ETL-databehandling på Talent.com med Amazon SageMaker | Amazon Web Services

Dette innlegget er medforfatter av Anatoly Khomenko, Machine Learning Engineer, og Abdenour Bezzouh, Chief Technology Officer hos Talent.com.

Etablert i 2011, Talent.com samler betalte stillingsannonser fra sine kunder og offentlige stillingsannonser, og har skapt en enhetlig, lett søkbar plattform. Talent.com dekker over 30 millioner stillingsannonser i mer enn 75 land og spenner over ulike språk, bransjer og distribusjonskanaler, og dekker de ulike behovene til jobbsøkere, og kobler effektivt millioner av jobbsøkere med jobbmuligheter.

Talent.coms oppgave er å legge til rette for globale arbeidsstyrkeforbindelser. For å oppnå dette, samler Talent.com stillingsannonser fra ulike kilder på nettet, og tilbyr jobbsøkere tilgang til en omfattende pool på over 30 millioner jobbmuligheter skreddersydd for deres ferdigheter og erfaringer. I tråd med dette oppdraget samarbeidet Talent.com med AWS for å utvikle en banebrytende jobbanbefalingsmotor drevet av dyp læring, rettet mot å hjelpe brukere med å fremme karrieren.

For å sikre effektiv drift av denne jobbanbefalingsmotoren, er det avgjørende å implementere en storskala databehandlingspipeline som er ansvarlig for å trekke ut og raffinere funksjoner fra Talent.coms aggregerte stillingsannonser. Denne rørledningen er i stand til å behandle 5 millioner daglige poster på mindre enn 1 time, og gjør det mulig å behandle flere dager med poster parallelt. I tillegg tillater denne løsningen en rask distribusjon til produksjon. Den primære datakilden for denne rørledningen er JSON Lines-formatet, lagret i Amazon enkel lagringstjeneste (Amazon S3) og partisjonert etter dato. Hver dag resulterer dette i generering av titusenvis av JSON Lines-filer, med inkrementelle oppdateringer som skjer daglig.

Hovedmålet med denne databehandlingspipelinen er å lette opprettelsen av funksjoner som er nødvendige for opplæring og distribusjon av jobbanbefalingsmotoren på Talent.com. Det er verdt å merke seg at denne pipelinen må støtte inkrementelle oppdateringer og imøtekomme de intrikate funksjonsutvinningskravene som er nødvendige for opplærings- og distribusjonsmodulene som er avgjørende for jobbanbefalingssystemet. Rørledningen vår tilhører den generelle ETL-prosessfamilien (ekstrahere, transformere og laste) som kombinerer data fra flere kilder til et stort, sentralt depot.

For ytterligere innsikt i hvordan Talent.com og AWS i samarbeid bygde banebrytende naturlig språkbehandling og dyplæringsmodellopplæringsteknikker, ved å bruke Amazon SageMaker for å lage et jobbanbefalingssystem, se Fra tekst til drømmejobb: Bygg en NLP-basert jobbanbefaler på Talent.com med Amazon SageMaker. Systemet inkluderer funksjonsteknikk, dyplæringsmodellarkitekturdesign, hyperparameteroptimalisering og modellevaluering, hvor alle moduler kjøres ved hjelp av Python.

Dette innlegget viser hvordan vi brukte SageMaker til å bygge en storskala databehandlingspipeline for å forberede funksjoner for jobbanbefalingsmotoren på Talent.com. Den resulterende løsningen gjør det mulig for en dataforsker å tenke ut funksjonsutvinning i en SageMaker-notisbok ved hjelp av Python-biblioteker, som f.eks. Scikit-Lær or PyTorch, og deretter raskt distribuere den samme koden i databehandlingsrørledningen som utfører funksjonsutvinning i stor skala. Løsningen krever ikke portering av funksjonsekstraksjonskoden for å bruke PySpark, slik det kreves ved bruk AWS Lim som ETL-løsningen. Løsningen vår kan kun utvikles og distribueres av en Data Scientist ende-til-ende ved bruk av kun en SageMaker, og krever ikke kunnskap om andre ETL-løsninger, som f.eks. AWS-batch. Dette kan betydelig forkorte tiden som trengs for å distribuere Machine Learning (ML) pipeline til produksjon. Rørledningen drives gjennom Python og integreres sømløst med arbeidsflyter for funksjonsutvinning, noe som gjør den tilpassbar til et bredt spekter av dataanalyseapplikasjoner.

Løsningsoversikt

Rørledningen består av tre primærfaser:

1. Bruk en Amazon SageMaker-prosessering jobb for å håndtere rå JSONL-filer knyttet til en spesifisert dag. Flere dager med data kan behandles av separate behandlingsjobber samtidig.
2. Anvende AWS Lim for datagjennomgang etter behandling av flere dager med data.
3. Last inn behandlede funksjoner for en spesifisert datoperiode ved å bruke SQL fra en Amazonas Athena tabell, tren og distribuer jobbanbefalingsmodellen.

Behandle rå JSONL-filer

Vi behandler rå JSONL-filer for en spesifisert dag ved å bruke en SageMaker Processing-jobb. Jobben implementerer funksjonsutvinning og datakomprimering, og lagrer behandlede funksjoner i Parkett-filer med 1 million poster per fil. Vi drar fordel av CPU-parallellisering for å utføre funksjonsekstraksjon for hver rå JSONL-fil parallelt. Behandlingsresultater for hver JSONL-fil lagres i en separat Parkett-fil i en midlertidig katalog. Etter at alle JSONL-filene er behandlet, utfører vi komprimering av tusenvis av små parkettfiler til flere filer med 1 million poster per fil. De komprimerte Parkett-filene blir deretter lastet opp til Amazon S3 som utdata for behandlingsjobben. Datakomprimeringen sikrer effektiv gjennomgang og SQL-spørringer i de neste stadiene av pipelinen.

Følgende er eksempelkoden for å planlegge en SageMaker-behandlingsjobb for en spesifisert dag, for eksempel 2020-01-01, ved å bruke SageMaker SDK. Jobben leser rå JSONL-filer fra Amazon S3 (for eksempel fra s3://bucket/raw-data/2020/01/01) og lagrer de komprimerte Parquet-filene i Amazon S3 (for eksempel til s3://bucket/processed/table-name/day_partition=2020-01-01/).

### install dependencies %pip install sagemaker pyarrow s3fs awswrangler import sagemaker
import boto3 from sagemaker.processing import FrameworkProcessor
from sagemaker.sklearn.estimator import SKLearn
from sagemaker import get_execution_role
from sagemaker.processing import ProcessingInput, ProcessingOutput region = boto3.session.Session().region_name
role = get_execution_role()
bucket = sagemaker.Session().default_bucket() ### we use instance with 16 CPUs and 128 GiB memory
### note that the script will NOT load the entire data into memory during compaction
### depending on the size of individual jsonl files, larger instance may be needed
instance = "ml.r5.4xlarge"
n_jobs = 8 ### we use 8 process workers
date = "2020-01-01" ### process data for one day est_cls = SKLearn
framework_version_str = "0.20.0" ### schedule processing job
script_processor = FrameworkProcessor( role=role, instance_count=1, instance_type=instance, estimator_cls=est_cls, framework_version=framework_version_str, volume_size_in_gb=500,
) script_processor.run( code="processing_script.py", ### name of the main processing script source_dir="../src/etl/", ### location of source code directory ### our processing script loads raw jsonl files directly from S3 ### this avoids long start-up times of the processing jobs, ### since raw data does not need to be copied into instance inputs=[], ### processing job input is empty outputs=[ ProcessingOutput(destination="s3://bucket/processed/table-name/", source="/opt/ml/processing/output"), ], arguments=[ ### directory with job's output "--output", "/opt/ml/processing/output", ### temporary directory inside instance "--tmp_output", "/opt/ml/tmp_output", "--n_jobs", str(n_jobs), ### number of process workers "--date", date, ### date to process ### location with raw jsonl files in S3 "--path", "s3://bucket/raw-data/", ], wait=False
)

Følgende kodeoversikt for hovedskriptet (processing_script.py) som kjører SageMaker Processing-jobben er som følger:

import concurrent
import pyarrow.dataset as ds
import os
import s3fs
from pathlib import Path ### function to process raw jsonl file and save extracted features into parquet file from process_data import process_jsonl ### parse command line arguments
args = parse_args() ### we use s3fs to crawl S3 input path for raw jsonl files
fs = s3fs.S3FileSystem()
### we assume raw jsonl files are stored in S3 directories partitioned by date
### for example: s3://bucket/raw-data/2020/01/01/
jsons = fs.find(os.path.join(args.path, *args.date.split('-'))) ### temporary directory location inside the Processing job instance
tmp_out = os.path.join(args.tmp_output, f"day_partition={args.date}") ### directory location with job's output
out_dir = os.path.join(args.output, f"day_partition={args.date}") ### process individual jsonl files in parallel using n_jobs process workers
futures=[]
with concurrent.futures.ProcessPoolExecutor(max_workers=args.n_jobs) as executor: for file in jsons: inp_file = Path(file) out_file = os.path.join(tmp_out, inp_file.stem + ".snappy.parquet") ### process_jsonl function reads raw jsonl file from S3 location (inp_file) ### and saves result into parquet file (out_file) inside temporary directory futures.append(executor.submit(process_jsonl, file, out_file)) ### wait until all jsonl files are processed for future in concurrent.futures.as_completed(futures): result = future.result() ### compact parquet files
dataset = ds.dataset(tmp_out) if len(dataset.schema) > 0: ### save compacted parquet files with 1MM records per file ds.write_dataset(dataset, out_dir, format="parquet", max_rows_per_file=1024 * 1024)

Skalerbarhet er en nøkkelfunksjon i vår pipeline. For det første kan flere SageMaker Processing-jobber brukes til å behandle data i flere dager samtidig. For det andre unngår vi å laste hele behandlede eller rådata inn i minnet på en gang, mens vi behandler hver spesifisert dag med data. Dette muliggjør behandling av data ved å bruke forekomsttyper som ikke kan romme en hel dags data i primærminnet. Det eneste kravet er at instanstypen skal være i stand til å laste inn N rå JSONL- eller behandlede Parquet-filer til minnet samtidig, med N som antall prosessarbeidere som er i bruk.

Gjennomgå behandlede data ved hjelp av AWS Glue

Etter at alle rådata for flere dager er behandlet, kan vi lage en Athena-tabell fra hele datasettet ved å bruke en AWS Glue-crawler. Vi bruker AWS SDK for pandaer (awswrangler) biblioteket for å lage tabellen ved å bruke følgende kodebit:

import awswrangler as wr ### crawl processed data in S3
res = wr.s3.store_parquet_metadata( path='s3://bucket/processed/table-name/', database="database_name", table="table_name", dataset=True, mode="overwrite", sampling=1.0, path_suffix='.parquet',
) ### print table schema
print(res[0])

Last inn behandlede funksjoner for trening

Behandlede funksjoner for en spesifisert datoperiode kan nå lastes fra Athena-tabellen ved hjelp av SQL, og disse funksjonene kan deretter brukes til å trene jobbanbefalingsmodellen. Følgende kodebit laster for eksempel én måned med behandlede funksjoner inn i en DataFrame ved hjelp av awswrangler bibliotek:

import awswrangler as wr query = """ SELECT * FROM table_name WHERE day_partition BETWEN '2020-01-01' AND '2020-02-01' """ ### load 1 month of data from database_name.table_name into a DataFrame
df = wr.athena.read_sql_query(query, database='database_name')

I tillegg kan bruken av SQL for lasting av behandlede funksjoner for opplæring utvides for å imøtekomme forskjellige andre brukstilfeller. For eksempel kan vi bruke en lignende pipeline for å opprettholde to separate Athena-tabeller: en for lagring av brukervisninger og en annen for lagring av brukerklikk på disse visningene. Ved å bruke SQL join-setninger kan vi hente visninger som brukere enten klikket på eller ikke klikket på, og deretter overføre disse visningene til en modellopplæringsjobb.

Løsningsfordeler

Implementering av den foreslåtte løsningen gir flere fordeler til vår eksisterende arbeidsflyt, inkludert:

• Forenklet implementering – Løsningen gjør det mulig å implementere funksjonsutvinning i Python ved å bruke populære ML-biblioteker. Og det krever ikke at koden porteres inn i PySpark. Dette strømlinjeformer funksjonsutvinning ettersom den samme koden utviklet av en dataforsker i en notatbok vil bli utført av denne rørledningen.
• Rask vei til produksjon – Løsningen kan utvikles og distribueres av en dataforsker for å utføre funksjonsutvinning i stor skala, slik at de kan utvikle en ML-anbefalingsmodell mot disse dataene. Samtidig kan den samme løsningen distribueres til produksjon av en ML-ingeniør med små modifikasjoner som trengs.
• Reus Evne – Løsningen gir et gjenbrukbart mønster for funksjonsutvinning i skala, og kan enkelt tilpasses for andre brukstilfeller utover byggeanbefalingsmodeller.
• Effektivitet – Løsningen gir god ytelse: behandler en enkelt dag av Talent.comsine data tok mindre enn 1 time.
• Inkrementelle oppdateringer – Løsningen støtter også inkrementelle oppdateringer. Nye daglige data kan behandles med en SageMaker Processing-jobb, og S3-lokasjonen som inneholder de behandlede dataene kan gjennomsøkes på nytt for å oppdatere Athena-tabellen. Vi kan også bruke en cron-jobb til å oppdatere dagens data flere ganger per dag (for eksempel hver tredje time).

Vi brukte denne ETL-pipelinen til å hjelpe Talent.com med å behandle 50,000 5 filer per dag som inneholder 90 millioner poster, og opprettet treningsdata ved å bruke funksjoner hentet fra 450 dager med rådata fra Talent.com – totalt 900,000 millioner poster fordelt på 2 8.6 filer. Vår pipeline hjalp Talent.com med å bygge og distribuere anbefalingssystemet i produksjon innen bare XNUMX uker. Løsningen utførte alle ML-prosesser inkludert ETL på Amazon SageMaker uten å bruke annen AWS-tjeneste. Jobanbefalingssystemet førte til en økning på XNUMX % i klikkfrekvensen i online A/B-testing mot en tidligere XGBoost-basert løsning, og bidro til å koble millioner av Talent.coms brukere til bedre jobber.

konklusjonen

Dette innlegget skisserer ETL-pipelinen vi utviklet for funksjonsbehandling for opplæring og distribusjon av en jobbanbefalingsmodell på Talent.com. Vår pipeline bruker SageMaker Processing-jobber for effektiv databehandling og funksjonsutvinning i stor skala. Funksjonsekstraksjonskode er implementert i Python som muliggjør bruk av populære ML-biblioteker for å utføre funksjonsekstraksjon i stor skala, uten behov for å portere koden for å bruke PySpark.

Vi oppfordrer leserne til å utforske muligheten for å bruke pipelinen presentert i denne bloggen som en mal for deres brukssaker der funksjonsutvinning i stor skala er nødvendig. Rørledningen kan utnyttes av en dataforsker til å bygge en ML-modell, og den samme rørledningen kan deretter tas i bruk av en ML-ingeniør for å kjøre i produksjon. Dette kan redusere tiden som trengs for å produsere ML-løsningen ende-til-ende betydelig, slik tilfellet var med Talent.com. Leserne kan henvise til veiledning for å sette opp og kjøre SageMaker Processing-jobber. Vi henviser også leserne til å se innlegget Fra tekst til drømmejobb: Bygg en NLP-basert jobbanbefaler på Talent.com med Amazon SageMaker, hvor vi diskuterer treningsteknikker for dyp læringsmodeller Amazon SageMaker å bygge Talent.coms jobbanbefalingssystem.

---

Om forfatterne

Dmitriy Bespalov er Senior Applied Scientist ved Amazon Machine Learning Solutions Lab, hvor han hjelper AWS-kunder på tvers av ulike bransjer med å akselerere deres AI og skyadopsjon.

Yi Xiang er en Applied Scientist II ved Amazon Machine Learning Solutions Lab, hvor hun hjelper AWS-kunder på tvers av ulike bransjer med å akselerere deres AI og skyadopsjon.

Tong Wang er Senior Applied Scientist ved Amazon Machine Learning Solutions Lab, hvor han hjelper AWS-kunder på tvers av ulike bransjer med å akselerere deres AI og skyadopsjon.

Anatoly Khomenko er senior maskinlæringsingeniør ved Talent.com med en lidenskap for naturlig språkbehandling som matcher gode mennesker til gode jobber.

Abdenour Bezzouh er en leder med mer enn 25 års erfaring med å bygge og levere teknologiløsninger som skaleres til millioner av kunder. Abdenour hadde stillingen som Chief Technology Officer (CTO) kl Talent.com da AWS-teamet designet og utførte denne spesielle løsningen for Talent.com.

Yanjun Qi er Senior Applied Science Manager ved Amazon Machine Learning Solution Lab. Hun innoverer og bruker maskinlæring for å hjelpe AWS-kunder med å få fart på AI og skyadopsjon.

• 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. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
• PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
• kilde: https://aws.amazon.com/blogs/machine-learning/streamlining-etl-data-processing-at-talent-com-with-amazon-sagemaker/