Machine Learning-pijpleidingen bouwen met Snowflake en Dask
In dit bericht wil ik enkele van de tools delen die ik onlangs heb onderzocht en laten zien hoe ik ze gebruik en hoe ze hebben geholpen de efficiëntie van mijn workflow te verbeteren. De twee waar ik het in het bijzonder over zal hebben zijn Snowflake en Dask. Twee heel verschillende tools, maar die elkaar goed aanvullen, vooral als onderdeel van de ML Lifecycle.
By Daniel Foley Fo, Data scientist
Introductie
De laatste tijd probeer ik betere manieren te vinden om mijn workflow als datawetenschapper te verbeteren. In mijn werk besteed ik meestal een behoorlijk deel van mijn tijd aan het modelleren en bouwen van ETL's. Dit heeft ertoe geleid dat ik steeds meer moet vertrouwen op tools om op betrouwbare en efficiënte wijze grote datasets te kunnen verwerken. Ik besefte al snel dat het gebruik van panda's voor het manipuleren van deze datasets niet altijd een goede aanpak is, en dit bracht mij ertoe om naar andere alternatieven te kijken.
In dit bericht wil ik enkele van de tools delen die ik onlangs heb onderzocht en laten zien hoe ik ze gebruik en hoe ze hebben geholpen de efficiëntie van mijn workflow te verbeteren. De twee waar ik het in het bijzonder over zal hebben zijn Snowflake en Dask. Twee heel verschillende tools, maar die elkaar goed aanvullen, vooral als onderdeel van de ML Lifecycle. Ik hoop dat je na het lezen van dit bericht een goed begrip zult hebben van wat Snowflake en Dask zijn, hoe ze effectief kunnen worden gebruikt en dat je aan de slag kunt met je eigen gebruiksscenario's.
Meer specifiek wil ik je laten zien hoe je een ETL-pijplijn kunt bouwen met behulp van Snowflake en Python om trainingsgegevens te genereren voor een machine learning-taak. Vervolgens wil ik Dask en Saturnus Cloud en laat u zien hoe u kunt profiteren van parallelle verwerking in de cloud om het ML-trainingsproces echt te versnellen, zodat u uw productiviteit als datawetenschapper kunt verhogen.
ETL's bouwen in Snowflake en Python
Voordat we beginnen met coderen, kan ik beter kort uitleggen wat Sneeuwvlok is. Dit is een vraag die ik onlangs heb gesteld toen mijn team besloot het te gaan gebruiken. Op hoog niveau is het een datawarehouse in de cloud. Na er een tijdje mee gespeeld te hebben, besefte ik hoe krachtig het was. Ik denk dat een van de handigste functies voor mij de virtuele magazijnen zijn die je kunt gebruiken. Een virtueel magazijn geeft u toegang tot dezelfde gegevens, maar is volledig onafhankelijk van andere virtuele magazijnen, zodat computerbronnen niet tussen teams worden gedeeld. Dit is erg nuttig gebleken omdat het de kans op prestatieproblemen wegneemt die worden veroorzaakt doordat andere gebruikers de hele dag door query's uitvoeren. Dit heeft geresulteerd in minder frustratie en tijdverspilling bij het wachten op het uitvoeren van query's.
Omdat we Snowflake gaan gebruiken, zal ik kort schetsen hoe je het kunt instellen en er zelf mee kunt gaan experimenteren. We moeten het volgende doen:
- Zorg ervoor dat u een Snowflake-account aanmaakt
- Haal onze gegevens op in Snowflake
- Schrijf en test onze query's met behulp van SQL en de Snowflake UI
- Schrijf een Python-klasse die onze query's kan uitvoeren om onze definitieve dataset voor modellering te genereren
Het opzetten van een account is net zo eenvoudig als het aanmelden voor een gratis proefperiode van de. Zodra je dat hebt gedaan, kun je de snowsql CLI downloaden hier. Dit maakt het eenvoudig om gegevens aan Snowflake toe te voegen. Nadat we deze stappen hebben gevolgd, kunnen we proberen verbinding te maken met Snowflake met behulp van onze inloggegevens en de opdrachtregel.
snowsql -a <account_name> -u <user_name>
U kunt uw accountnaam vinden in de URL wanneer u zich aanmeldt bij de Snowflake-gebruikersinterface. Het zou er ongeveer zo uit moeten zien: xxxxx.europe-west2.gcp. Oké, laten we naar de volgende stap gaan en onze gegevens in Snowflake krijgen. Er zijn een paar stappen die we hier moeten volgen, namelijk:
- Creëer ons virtuele magazijn
- Maak een database
- Definieer en creëer onze tabellen
- Maak een faseringstabel voor onze CSV-bestanden
- Kopieer de gegevens naar onze tabellen
Gelukkig is dit niet zo moeilijk en kunnen we dit volledig doen met behulp van de snowsql CLI. Voor dit project zal ik een kleinere dataset gebruiken dan ik zou willen, maar helaas kan ik de gegevens van mijn bedrijf niet gebruiken en kan het behoorlijk moeilijk zijn om grote, geschikte datasets online te vinden. Ik heb echter wel enkele transactiegegevens van Dunnhumby gevonden die gratis beschikbaar zijn op Kaggle. Maar voor de lol creëer ik een veel grotere synthetische dataset met behulp van deze gegevens om te testen hoe goed Dask met de uitdaging omgaat in vergelijking met sklearn.
Allereerst moeten we een virtueel magazijn en een database opzetten met behulp van de volgende opdrachten in de Snowflake-gebruikersinterface.
en je merk te creëren or vervangen magazijnanalyse_wh Met
magazijn_size=”X-KLEIN”
auto_suspend=180
auto_resume=waar
aanvankelijk_opgeschort=waar;
en je merk te creëren or vervangen databank dunnhumby;
Onze gegevens bestaan uit 6 CSV's die we zullen omzetten in 6 tabellen. Ik zal niet te veel tijd besteden aan het doornemen van de dataset, aangezien dit bericht meer gaat over het gebruik van Snowflake en Dask dan over het interpreteren van gegevens.
Hieronder staan de opdrachten die we kunnen gebruiken om onze tabellen te maken. Het enige dat u van tevoren hoeft te weten, is met welke kolommen en gegevenstypen u gaat werken.
create or replace table campaign_desc ( description string, campaign number,
start_day number,
end_day number ); create or replace table campaign_table ( description string, Household_key number, campaign number ); create or replace table coupon ( COUPON_UPC number, product_id number, campaign number ); create or replace table coupon_redempt ( household_key number, day number, coupon_upc number, campaign number ); create or replace table transactions ( household_key number, BASKET_ID number, day number, product_id number, quantity number, sales_value number, store_id number, retail_disc decimal, trans_time number, week_no number, coupon_disc decimal, coupon_match_disc decimal ); create or replace table demographic_data ( age_dec string, marital_status_code string, income_desc string, homeowner_desc string, hh_comp_desc string, household_size_desc string, kid_category_desc string, Household_key number);
Nu we onze tabellen hebben gemaakt, kunnen we gaan nadenken over hoe we er gegevens in kunnen krijgen. Hiervoor moeten we onze CSV-bestanden voorbereiden. Dit is eigenlijk slechts een tussenstap, zodat Snowflake de bestanden rechtstreeks van ons podium in onze tabellen kan laden. Wij kunnen gebruik maken van de PUT opdracht om lokale bestanden in ons werkgebied te plaatsen en vervolgens de KOPIEER NAAR opdracht om Snowflake te instrueren waar deze gegevens moeten worden geplaatst.
use database dunnhumby; create or replace stage dunnhumby_stage; PUT file://campaigns_table.csv @dunnhumby.public.dunnhumby_stage; PUT file://campaigns_desc.csv @dunnhumby.public.dunnhumby_stage; PUT file://coupon.csv @dunnhumby.public.dunnhumby_stage; PUT file://coupon_d=redempt.csv @dunnhumby.public.dunnhumby_stage; PUT file://transaction_data.csv @dunnhumby.public.dunnhumby_stage; PUT file://demographics.csv @dunnhumby.public.dunnhumby_stage;
Als snelle controle kunt u deze opdracht uitvoeren om te controleren wat zich in het verzamelgebied bevindt.
ls @dunnhumby.public.dunnhumby_stage;
Nu hoeven we alleen maar de gegevens naar onze tabellen te kopiëren met behulp van de onderstaande zoekopdrachten. Je kunt deze uitvoeren in de Snowflake-gebruikersinterface of op de opdrachtregel nadat je bent ingelogd bij Snowflake.
copy into campaign_table from @dunnhumby.public.dunnhumby_stage/campaigns_table.csv.gz file_format = ( type = csv
skip_header=1 error_on_column_count_mismatch = false field_optionally_enclosed_by=’”’); copy into campaign_desc from @dunnhumby.public.dunnhumby_stage/campaign_desc.csv.gz file_format = ( type = csv
skip_header=1 error_on_column_count_mismatch = false field_optionally_enclosed_by=’”’); copy into coupon from @dunnhumby.public.dunnhumby_stage/coupon.csv.gz file_format = ( type = csv
skip_header=1 error_on_column_count_mismatch = false field_optionally_enclosed_by=’”’); copy into coupon_redempt from @dunnhumby.public.dunnhumby_stage/coupon_redempt.csv.gz file_format = ( type = csv
skip_header=1 error_on_column_count_mismatch = false field_optionally_enclosed_by=’”’); copy into transactions from @dunnhumby.public.dunnhumby_stage/transaction_data.csv.gz file_format = ( type = csv
skip_header=1 error_on_column_count_mismatch = false field_optionally_enclosed_by=’”’); copy into demographic_data from @dunnhumby.public.dunnhumby_stage/demographics.csv.gz file_format = ( type = csv skip_header=1 error_on_column_count_mismatch = false field_optionally_enclosed_by=’”’);
Oké, geweldig, met een beetje geluk hebben we onze gegevens bij de eerste poging in onze tabellen. Oh, als het maar zo simpel was, kostte dit hele proces me een paar pogingen om het goed te krijgen (pas op voor het verkeerd spellen van dingen). Hopelijk kun je dit volgen en ben je goed om te gaan. We komen dichter bij de interessante dingen, maar de bovenstaande stappen zijn een essentieel onderdeel van het proces, dus zorg ervoor dat u elk van deze stappen begrijpt.
Onze pijplijn schrijven in SQL
In deze volgende stap zullen we de query's schrijven om ons doel en onze functies te genereren en uiteindelijk een trainingsdataset te produceren. Eén benadering voor het maken van een dataset voor modellering is om deze gegevens in het geheugen te lezen en panda's te gebruiken om nieuwe functies te creëren en alle dataframes samen te voegen. Dit is meestal de aanpak die je ziet op Kaggle en in andere online tutorials. Het probleem hiermee is dat het niet erg efficiënt is, vooral als je met datasets van redelijk grote omvang werkt. Om deze reden is het een veel beter idee om het zware werk uit te besteden aan zoiets als Snowflake, dat enorme datasets buitengewoon goed verwerkt en je waarschijnlijk enorm veel tijd zal besparen. Ik zal hier niet veel tijd besteden aan het duiken in de details van onze dataset, omdat deze niet echt van vitaal belang zijn voor wat ik probeer te laten zien. Over het algemeen zou u echter een aanzienlijke hoeveelheid tijd willen besteden aan het verkennen en begrijpen van uw gegevens voordat u begint met modelleren. Het doel van deze query's is om de gegevens voor te verwerken en enkele eenvoudige functies te creëren die we later in onze modellen kunnen gebruiken.
Doeldefinitie
Het is duidelijk dat een essentieel onderdeel van begeleid machinaal leren het definiëren van een geschikt doelwit is om te voorspellen. Voor ons gebruik voorspellen we het klantverloop door te berekenen of een gebruiker binnen twee weken na een afsluitweek al dan niet opnieuw een bezoek brengt. De keuze van 2 weken is vrij willekeurig en zal afhangen van het specifieke probleem dat we proberen op te lossen, maar laten we er maar van uitgaan dat dit prima is voor dit project. Over het algemeen wilt u uw klanten zorgvuldig analyseren om inzicht te krijgen in de verdeling van de perioden tussen bezoeken en zo tot een passende definitie van klantverloop te komen.
Het belangrijkste idee hier is dat we voor elke tabel één rij per huishouden_sleutel willen hebben met waarden voor elk van onze kenmerken.
Campagnefuncties
Transactiefuncties
Hieronder creëren we enkele eenvoudige statistieken op basis van geaggregeerde statistieken zoals het gemiddelde, de maximale afwijking en de standaardafwijking.
Demografische kenmerken
Deze dataset bevat veel ontbrekende gegevens, dus heb ik besloten hier imputatie te gebruiken. Er zijn tal van technieken beschikbaar om ontbrekende gegevens te verwijderen, van het laten vallen van de ontbrekende gegevens tot geavanceerde imputatiemethoden. Ik heb het mezelf hier zojuist gemakkelijk gemaakt en ontbrekende waarden vervangen door de modus. Ik zou deze benadering in het algemeen niet noodzakelijkerwijs aanbevelen, omdat begrijpen waarom deze gegevens ontbreken erg belangrijk is bij het beslissen hoe ermee om te gaan, maar voor de doeleinden van dit voorbeeld zal ik doorgaan en de gemakkelijke benadering kiezen. We berekenen eerst de modus voor elk van onze functies en gebruiken vervolgens coalesce om elke rij te vervangen door de modus als er gegevens ontbreken.
Trainingsdata
Ten slotte bouwen we een query voor onze trainingsgegevens door onze hoofdtabellen samen te voegen en eindigen we met een tabel met ons doel, onze campagne, transacties en demografische kenmerken die we kunnen gebruiken om een model te bouwen.
Even terzijde: voor degenen die meer willen weten over de kenmerken en nuances van Snowflake, zou ik het volgende boek aanbevelen: Sneeuwvlok kookboek. Ik begon dit boek te lezen en het staat vol met heel nuttige informatie over het gebruik van Snowflake en gaat veel gedetailleerder in dan ik hier doe.
Python-code voor ETL
Het laatste stuk dat we nodig hebben voor deze ETL is het schrijven van een script om het uit te voeren. Dit is alleen echt nodig als u van plan bent een dergelijke ETL regelmatig uit te voeren, maar dit is een goede gewoonte en maakt het veel gemakkelijker om de ETL uit te voeren wanneer dat nodig is.
Laten we kort de belangrijkste componenten van onze EtlTraining-les bespreken. Onze klas heeft één input nodig, namelijk de cutoff-week. Dit komt door de manier waarop gegevens in onze dataset worden gedefinieerd, maar normaal gesproken zou dit in een datumnotatie zijn die overeenkomt met de afsluitdatum die we willen kiezen voor het genereren van trainingsgegevens.
We initialiseren een lijst met onze vragen, zodat we deze gemakkelijk kunnen doornemen en uitvoeren. We maken ook een woordenboek met onze parameters die we doorgeven aan onze Snowflake-verbinding. Hier gebruiken we omgevingsvariabelen die we hebben ingesteld in Saturn Cloud. Here is een handleiding over hoe u dit kunt doen. Het is niet zo moeilijk om verbinding te maken met Snowflake, het enige dat we hoeven te doen is de Snowflake-connector gebruiken en ons woordenboek met inloggegevens doorgeven. We implementeren dit in de Snowflake connect-methode en retourneren deze verbinding als attribuut.
Om deze query's een beetje eenvoudiger uit te voeren, sla ik elke query op als een Python-tekenreeksvariabele in het bestand ml_query_pipeline.py. De execute_etl-methode doet precies wat er op het blik staat. We doorlopen elke query, formatteren deze, voeren deze uit en sluiten af door de Snowflake-verbinding te sluiten.
Om deze ETL uit te voeren, kunnen we eenvoudigweg de onderstaande opdrachten in de terminal typen. (waarbij ml_pipeline de naam is van het bovenstaande script.)
python -m ml_pipeline -w 102 -j ‘train’
Even terzijde: u zult waarschijnlijk een dergelijke ETL met regelmatige tussenpozen willen uitvoeren. Als u bijvoorbeeld dagelijkse voorspellingen wilt doen, moet u elke dag een dataset als deze genereren om door te geven aan uw model, zodat u kunt identificeren welke van uw klanten waarschijnlijk zullen afhaken. Ik zal hier niet in detail op ingaan, maar in mijn werk gebruiken we Airflow om onze ETL's te orkestreren, dus ik zou aanraden om het eens te bekijken als je geïnteresseerd bent. Sterker nog, ik heb onlangs een boek gekocht 'Gegevenspijplijnen met Apache Airflow' wat ik geweldig vind en echt een aantal solide voorbeelden en advies geeft over het gebruik van de luchtstroom.
Dask en modellering
Nu we onze datapijplijn hebben opgebouwd, kunnen we beginnen na te denken over modellering. Het andere hoofddoel dat ik voor dit bericht heb, is om de voordelen van het gebruik van Dask als onderdeel van het ML-ontwikkelingsproces te benadrukken en jullie te laten zien hoe gemakkelijk het te gebruiken is.
Voor dit deel van het project heb ik ook gebruikt Saturnus Cloud wat een heel leuk hulpmiddel is dat ik onlangs tegenkwam en waarmee we de kracht van Dask kunnen benutten op een cluster van computers in de cloud. De belangrijkste voordelen van het gebruik van Saturn voor mij zijn dat het heel gemakkelijk is om uw werk te delen, supereenvoudig om uw computer op te schalen wanneer en wanneer u het nodig hebt, en dat het een gratis laagoptie heeft. Modelontwikkeling in het algemeen is een heel goed gebruiksscenario voor Dask, omdat we meestal een aantal verschillende modellen willen trainen en kijken wat het beste werkt. Hoe sneller we dit kunnen doen, hoe beter, omdat we meer tijd hebben om ons te concentreren op andere belangrijke aspecten van modelontwikkeling. Net als bij Snowflake hoeft u zich alleen maar aan te melden hier en je kunt heel snel een exemplaar van Jupyter lab opstarten en er zelf mee gaan experimenteren.
Nu besef ik dat ik Dask een paar keer heb genoemd, maar nooit echt heb uitgelegd wat het is. Dus laat me even de tijd nemen om je een overzicht op zeer hoog niveau te geven van Dask en waarom ik het geweldig vind. Heel eenvoudig: Dask is een Python-bibliotheek die gebruik maakt van parallel computergebruik, zodat u zeer grote datasets kunt verwerken en uitvoeren. En het beste is dat als je al bekend bent met Python, Dask heel eenvoudig zou moeten zijn, omdat de syntaxis erg op elkaar lijkt.
De onderstaande grafiek belicht de belangrijkste componenten van Dask.
Bron: Dask-documentatie
Met verzamelingen kunnen we een grafiek van taken maken die vervolgens op meerdere computers kan worden uitgevoerd. Sommige van deze datastructuren klinken waarschijnlijk behoorlijk bekend, zoals arrays en dataframes, en ze zijn vergelijkbaar met wat je in Python zou vinden, maar met enkele belangrijke verschillen. U kunt een Dask-dataframe bijvoorbeeld zien als een stel panda-dataframes die zo zijn gebouwd dat we bewerkingen parallel kunnen uitvoeren.
Als we verder gaan met collecties, hebben we de planner. Zodra we de taakgrafiek hebben gemaakt, regelt de planner de rest voor ons. Het beheert de workflow en stuurt deze taken naar één enkele machine of verdeelt ze over een cluster. Hopelijk geeft dit je een heel kort overzicht van hoe Dask werkt. Voor meer informatie raad ik aan om de documentatie of dit boek. Beide zijn zeer goede bronnen om dieper op dit onderwerp in te gaan.
Python-code voor modellering
Bij het modelleren heb ik meestal een klein aantal go-to-algoritmen die ik altijd eerst zal uitproberen. Dit zal mij over het algemeen een goed idee geven van wat geschikt zou kunnen zijn voor het specifieke probleem dat ik heb. Deze modellen zijn Logistic Regression, Random Forest en GradientBoosting. Mijn ervaring is dat deze algoritmen bij het werken met tabelgegevens meestal behoorlijk goede resultaten opleveren. Hieronder bouwen we een sklearn-modelleringspijplijn met behulp van deze 3 modellen. De exacte modellen die we hier gebruiken zijn niet echt belangrijk, aangezien de pijplijn voor elk sklearn-classificatiemodel zou moeten werken, dit is slechts mijn voorkeur.
Laten we zonder verder oponthoud in de code duiken. Gelukkig hebben we het grootste deel van onze voorverwerking uitbesteed aan Snowflake, zodat we hier niet te veel met onze trainingsgegevens hoeven te rommelen, maar we zullen een paar extra stappen toevoegen met behulp van sklearn-pijplijnen.
Het eerste codefragment hieronder toont de pijplijn bij gebruik van sklearn. Merk op dat onze dataset een eenvoudig oud panda-dataframe is en dat onze voorverwerkingsstappen allemaal worden uitgevoerd met behulp van sklearn-methoden. Er is hier niets bijzonders aan de hand. We lezen onze gegevens in uit de tabel die is geproduceerd door onze Snowflake ETL en geven deze door aan een sklearn-pijplijn. Hier zijn de gebruikelijke modelleringsstappen van toepassing. We splitsen de dataset op in trainen en testen en voeren wat voorbewerking uit, namelijk het toeschrijven van ontbrekende waarden met behulp van de mediaan, het schalen van de gegevens en het in één keer coderen van onze categorische gegevens. Ik ben een grote fan van sklearn-pijplijnen en gebruik ze tegenwoordig eigenlijk wanneer ik modellen ontwikkel, ze vergemakkelijken echt schone en beknopte code.
Hoe presteert deze pijplijn op een dataset met ongeveer 2 miljoen rijen? Het uitvoeren van dit model zonder enige afstemming van de hyperparameters duurt ongeveer 34 minuten. Au, nogal langzaam. Je kunt je voorstellen hoe onbetaalbaar lang dit zou duren als we enige vorm van afstemming van hyperparameters zouden willen uitvoeren. Oké, dus niet ideaal, maar laten we eens kijken hoe Dask met de uitdaging omgaat.
Dask ML Python-code
Ons doel hier is om te zien of we de sklearn-pijplijn hierboven kunnen verslaan, spoiler alert, dat kunnen we zeker. Het leuke van Dask is dat de toegangsdrempel als je al bekend bent met Python vrij laag is. We kunnen deze pijplijn in Dask met slechts een paar wijzigingen operationeel krijgen.
De eerste verandering die u waarschijnlijk zult opmerken, is dat we een aantal andere importproducten hebben. Een van de belangrijkste verschillen tussen deze pijplijn en de vorige is dat we een Dask-dataframe zullen gebruiken in plaats van een Pandas-dataframe om ons model te trainen. Je kunt een Dask-dataframe zien als een stel panda-dataframes waar we tegelijkertijd berekeningen op kunnen uitvoeren. Dit is de kern van het parallellisme van Dask en wat de trainingstijd voor deze pijplijn gaat verkorten.
Merk op dat we gebruiken @dask.vertraagd als decorateur voor onze belasting_training_data functie. Dit geeft Dask de opdracht om deze functie voor ons te parallelliseren.
We gaan ook enkele voorverwerkings- en pijplijnmethoden van Dask importeren en het allerbelangrijkste: we zullen SaturnCluster moeten importeren, waardoor we een cluster kunnen creëren voor het trainen van onze modellen. Een ander belangrijk verschil met deze code is dat we gebruiken dag.persist na onze treintestsplitsing. Vóór dit punt is geen van onze functies daadwerkelijk berekend vanwege de luie evaluatie van Dask. Zodra we de persistent-methode gebruiken, vertellen we Dask echter dat hij onze gegevens naar de werkers moet sturen en de taken moet uitvoeren die we tot nu toe hebben gemaakt en deze objecten op het cluster moet laten.
Ten slotte trainen we onze modellen met behulp van de vertraagde methode. Nogmaals, dit stelt ons in staat om onze pijplijn op een luie manier te creëren. De pijplijn wordt pas uitgevoerd als we deze code bereiken:
fit_pipelines = dask.compute(*pipelines_)
Deze keer kostte het ons slechts ongeveer 10 minuten om deze pijplijn op exact dezelfde dataset uit te voeren. Dat is een versnelling van een factor 3.4, niet al te armoedig. Als we dat zouden willen, zouden we dit nog sneller kunnen doen door onze computerbronnen met één druk op de knop in Saturnus op te schalen.
Implementatie van onze pijplijn
Ik heb eerder gezegd dat je waarschijnlijk een pijpleiding als deze vrij regelmatig wilt laten draaien met behulp van zoiets als luchtstroom. Het gebeurt gewoon zo dat als je geen zin hebt in het initiële gedoe om alles in te stellen voor de luchtstroom, Saturn Cloud een eenvoudig alternatief biedt met Jobs. Dankzij taken kunnen we onze code inpakken en met regelmatige tussenpozen of indien nodig uitvoeren. Het enige wat u hoeft te doen is naar een bestaand project te gaan en op een vacature te klikken. Zodra we dat doen, zou het er als volgt uit moeten zien:
Bron: Saturnus
Vanaf hier hoeven we er alleen maar voor te zorgen dat onze Python-bestanden hierboven in de map in de afbeelding staan en kunnen we onze Python-opdracht hierboven invoeren
python -m ml_pipeline -w 102 -j 'train'
We kunnen ook een schema opstellen met behulp van de cron-syntaxis om de ETL dagelijks uit te voeren als we dat willen. Voor de geïnteresseerden, hier is een Tutorial dat gaat tot in de puntjes.
Conclusies en afhaalrestaurants
Welnu, op dit punt zijn we aan het einde van ons project gekomen. Nu heb ik uiteraard enkele belangrijke onderdelen van de ML-ontwikkelingscyclus weggelaten, zoals het afstemmen van hyperparameters en het inzetten van ons model, maar misschien zal ik dat nog een dag laten staan. Denk ik dat je Dask moet proberen? Ik ben op geen enkele manier een expert, maar van wat ik tot nu toe heb gezien lijkt het zeker erg nuttig en ik ben super enthousiast om er meer mee te experimenteren en meer mogelijkheden te vinden om het in mijn dagelijkse werk als datawetenschapper te integreren. Hopelijk vond je dit nuttig en kun jij ook enkele van de voordelen van Snowflake en Dask zien en ga je er zelf mee experimenteren.
Resources
- Gegevenspijplijnen met Apache Airflow
- Sneeuwvlok kookboek
- Datawetenschap op schaal met Python en Dask
- Cursus: SQL voor Data Science
Sommige van mijn andere berichten vindt u wellicht interessant
Laten we een streamingdatapijplijn bouwen
Gaussiaanse mengselmodellering (GMM)
Een Bayesiaanse benadering van tijdreeksvoorspellingen
Opmerking: sommige links in dit bericht zijn affiliatielinks.
Bio: Daniel Foley Fo is een voormalige econoom die datawetenschapper is geworden en werkzaam is in de mobiele gamingindustrie.
ORIGINELE. Met toestemming opnieuw gepost.
Zie ook:
Bron: https://www.kdnuggets.com/2021/07/building-machine-learning-pipelines-snowflake-dask.html
- "
- &
- 102
- 2021
- toegang
- Account
- Extra
- Voordeel
- advies
- Affiliate
- algoritmen
- Alles
- Amazone
- apache
- GEBIED
- rond
- auto
- BEST
- Beetje
- bouw
- Gebouw
- Bos
- Campagne
- gevallen
- veroorzaakt
- uitdagen
- verandering
- controleren
- classificatie
- dichterbij
- Cloud
- code
- codering
- bestanddeel
- Berekenen
- computers
- computergebruik
- Coursera
- Wij creëren
- Geloofsbrieven
- Klanten
- gegevens
- data science
- data scientist
- gegevensset
- datawarehouse
- Database
- dag
- transactie
- diepgaand leren
- demografisch
- detail
- ontwikkelen
- Ontwikkeling
- DEED
- Director
- doeltreffendheid
- Ingenieurs
- Milieu
- experiment
- Voordelen
- Tot slot
- einde
- Voornaam*
- Focus
- volgen
- formaat
- Gratis
- vol
- functie
- gaming
- Gaming-industrie
- Algemeen
- goed
- GPU's
- groot
- gids
- hier
- Hoge
- Markeer
- Hoe
- How To
- HTTPS
- reusachtig
- idee
- identificeren
- beeld
- Laat uw omzet
- -industrie
- info
- informatie
- problemen
- IT
- Jobomschrijving:
- Vacatures
- mee
- springen
- sleutel
- Groot
- LEARN
- leren
- Niveau
- Bibliotheek
- Lijn
- Lijst
- laden
- lokaal
- lang
- machine learning
- Metriek
- miljoen
- ML
- Mobile
- Mobiel gamen
- model
- beweging
- namelijk
- Nieuwe mogelijkheden
- Aanbod
- online.
- Operations
- Keuze
- Overige
- prestatie
- Overvloed
- Berichten
- energie
- Voorspellingen
- geproduceerd
- produktiviteit
- project
- publiek
- Python
- lezing
- verminderen
- regressie
- Resources
- REST
- Resultaten
- lopen
- lopend
- Scale
- scaling
- Wetenschap
- wetenschappers
- -Series
- reeks
- het instellen van
- Delen
- gedeeld
- Eenvoudig
- Klein
- So
- OPLOSSEN
- snelheid
- besteden
- Uitgaven
- spinnen
- spleet
- SQL
- Stadium
- begin
- gestart
- statistiek
- Blog
- streaming
- doelwit
- proef
- het denken
- niet de tijd of
- top
- Trainingen
- transactie
- Transacties
- proces
- tutorials
- ui
- us
- gebruikers
- Virtueel
- Magazijn
- week
- Wat is
- binnen
- Mijn werk
- werknemers
- workflow
- Bedrijven
- het schrijven van
- X
- jaar