Machine Learning-modellen trainen met TrueFoundry Jobs

Inleiding

In deze blog laten we je zien hoe je machine learning-modellen traint op het TrueFoundry Platform. We bespreken hoe we training jobs kunnen uitvoeren op TrueFoundry. Ook laten we zien hoe je eenvoudig hyperparameter tuning kunt uitvoeren voor je machine learning-modellen en hoe je jouw jobs op GPU's laat draaien.

Probleemstelling

Laten we beginnen met een probleemstelling: stel dat we willen zien hoe de ziekte diabetes zich bij een patiënt ontwikkelt op basis van verschillende kenmerken zoals leeftijd, BMI, bloeddruk, enz. In deze blog trainen we het Diabetes Dataset machine learning-model in scikit-learn.

Wat betreft het trainen van machine learning-modellen zijn er verschillende manieren om dit te doen, zoals lokaal trainen op je eigen computer, trainen in Jupyter Notebooks, enz. Het trainingsproces kan echter meer rekenkracht en geheugen vereisen dan beschikbaar is op een lokale machine.

Dit is waar TrueFoundry Jobs uitkomst biedt: je kunt de trainingscode implementeren om op een externe machine uit te voeren, terwijl je de logs en metrics kunt bijhouden.

Opmerking: Hoewel we deze diabetes-dataset gebruiken, zijn de instructies in deze blog ook van toepassing op andere machine learning- / deep learning-modellen.

Wat is een TrueFoundry Job?

Jobs bieden een manier om kortstondige, parallelle of sequentiële batchtaken binnen het cluster uit te voeren. Jobs zijn ontworpen om volledig afgerond te worden, in plaats van te fungeren als langdurig draaiende services of continu actieve applicaties. Zodra een job is voltooid, worden de reken- en geheugenbronnen vrijgegeven, waardoor er geen extra kosten worden gemaakt.

Model Training Job op TrueFoundry

Zoals eerder vermeld, gebruiken we de Diabetes Dataset in scikit-learn. De dataset bevat 442 samples (patiënten) en 10 features, die allemaal numeriek zijn. De features vertegenwoordigen verschillende factoren die de progressie van diabetes bij patiënten kunnen beïnvloeden. De doelvariabele is eveneens numeriek en geeft een kwantitatieve maatstaf voor de ziekteprogressie één jaar na de nulmeting voor elke patiënt.

Instelinstructies

Voordat we verdergaan met het trainen van machine learning-modellen, lopen we eerst de instelinstructies door:

Een Workspace aanmaken

Ga naar het TrueFoundry Dashboard en maak een account aan. Zodra je inlogt, wordt je gevraagd een workspace aan te maken. In deze workspace ga je jouw jobs deployen.

Een ML Repo aanmaken

Nadat je jouw workspace hebt aangemaakt, ga je naar het dashboard om een ML Repository aan te maken.

Een ML Repository is een verzameling van runs, modellen en artifacts die samen een Machine Learning-project vertegenwoordigen. Je kunt het zien als een git-repository, maar dan voor artifacts, modellen en metadata. Alle toegangsrechten kunnen worden geconfigureerd op het niveau van de ml-repo.

ML Repo-toegang toevoegen aan je Workspace

Zodra de ML Repo is aangemaakt, ga je naar workspaces, bewerk je jouw workspace en schakel je 'ML Repo Access' in. Klik op 'Add ML Repo Access' om je ML Repo aan deze workspace toe te voegen. Hiermee krijgt de job die in de workspace draait toestemming om te schrijven naar en te lezen uit de ML repo.

servicefoundry installeren

pip install servicefoundry


Inloggen op TrueFoundry

--host: Vul hier de URL van je TrueFoundry Dashboard in

sfy login --host <YOUR-HOST-URL-HERE>


Aangezien we de bovenstaande instelinstructies hebben afgerond, kunnen we doorgaan naar het implementatiedeel.

Implementatie

Mapstructuur

In deze blog hanteren we de volgende mapstructuur:

❯ tree
.
├── deploy.py
├── requirements.txt
└── train.py


Laten we nu de trainingscode voor het diabetesmodel doornemen:

Stappen voor het trainen van het model

Stap 1: Importeer de vereiste bibliotheken

from sklearn.metrics import accuracy_score
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.compose import TransformedTargetRegressor
from sklearn.preprocessing import QuantileTransformer
from sklearn.svm import SVR


Stap 2: Laad de dataset

X, y = load_diabetes(as_frame=True, return_X_y=True)


Stap 3: Splits de dataset in trainings- en testsets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


Stap 4: Maak en train het machine learning-model

regressor = SVR(kernel=kernel)
model = TransformedTargetRegressor(
   regressor=regressor,
   transformer=QuantileTransformer(n_quantiles=n_quantiles, output_distribution="normal"),
)
model.fit(X_train, y_train)


Stap 5: Maak voorspellingen op de testdata

y_pred = model.predict(X_test)


Stap 6: Evalueer de prestaties van het model

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")


Volledige code voor modeltraining

from sklearn.metrics import accuracy_score
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.compose import TransformedTargetRegressor
from sklearn.preprocessing import QuantileTransformer
from sklearn.svm import SVR

def train(kernel: str, n_quantiles: int):
   # load the dataset and create train and test sets
   X, y = load_diabetes(as_frame=True, return_X_y=True)
   
   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
   
   # initialize the model
   regressor = SVR(kernel=kernel)
   model = TransformedTargetRegressor(
       regressor=regressor,
       transformer=QuantileTransformer(n_quantiles=n_quantiles, output_distribution="normal"),
   )
   
   # train and test model
   model.fit(X_train, y_train)
   y_pred = model.predict(X_test)
   
   accuracy = accuracy_score(y_test, y_pred)
   print(f"Accuracy: {accuracy:.2f}"
   
   return regressor, model, X_test, y_test


Nu we de code voor het trainen van een machine learning-model hebben bekeken, kunnen we leren hoe we zulke modellen kunnen opslaan (of loggen) voor toekomstig gebruik.

Een Model bestaat uit een modelbestand en aanvullende metadata. Elk Model kan meerdere versies hebben. We kunnen modelobjecten automatisch serialiseren, opslaan en van een versie voorzien door de save_model_metadata-methode te gebruiken. Dit zijn de stappen om dat te doen:

Stappen voor het loggen van een model

Stap 1: Importeer de vereiste bibliotheken

import mlfoundry


Stap 2: Maak een ML Repo Run aan

run = mlfoundry.get_client().create_run(ml_repo=ml_repo, run_name="SVR-with-QT")


Een Run vertegenwoordigt een enkel experiment, wat in de context van Machine Learning staat voor één specifiek model (bijvoorbeeld Logistische Regressie) met een vaste set hyperparameters. Metrics en parameters (hieronder toegelicht) worden allemaal onder een specifieke run gelogd.

Stap 3: Log hyperparameters van het model

run.log_params(regressor.get_params())


Stap 4: Log modelmetrics

run.log_metrics({"score": model.score(X_test, y_test)})


Stap 5: Serialiseer en log een model met versiebeheer

model_version = run.log_model(name="diabetes-regression", model=model, framework="sklearn")
print("model_version =", model_version.version, "model_fqn =", model_version.model_fqn)


Elk gelogd model genereert een nieuwe versie die is gekoppeld aan de opgegeven name en verbonden is met de huidige run. Meerdere versies van het model kunnen als afzonderlijke versies onder dezelfde name worden gelogd.

Volledige code voor het loggen van het model

import mlfoundry

def save_model_metadata(regressor, model, X_test, y_test, ml_repo):
   # create a run in truefoundry’s ml_repo
   run = mlfoundry.get_client().create_run(ml_repo=ml_repo, run_name="SVR-with-QT")
   
   # log the hyperparameters of the model
   run.log_params(regressor.get_params())
   
   # log the metrics of the model
   run.log_metrics({"score": model.score(X_test, y_test)})
   
   # log the model
   model_version = run.log_model(name="diabetes-regression", model=model, framework="sklearn")
   
   print("model_version =", model_version.version, "model_fqn =", model_version.model_fqn)


Nu we het proces van modeltraining en -logging hebben gezien, kunnen we dit samenvoegen in één enkel train.py-bestand. De uiteindelijke inhoud van het bestand train.py ziet er als volgt uit:

train.py

# required import statements for both functions

def train(kernel, n_quantiles):
   ...

def save_model_metadata(regressor, model, X_test, y_test, ml_repo):
   ...

regressor, model, X_test, y_test = train(kernel="linear", n_quantiles=100)
save_model_metadata(regressor, model, X_test, y_test, ml_repo="YOUR ML REPO NAME")


Hiermee is onze code voor het trainen en loggen van het model compleet. Nu moeten we de modeltrainingscode deployen als een job. De deploy.py bevat de code om de bovenstaande modeltrainingscode te deployen, zoals hieronder getoond:

deploy.py

from servicefoundry import Build, Job, PythonBuild, LocalSource

# defining the job specifications
job = Job(
   name="diabetes-train-job",
   image=Build(
       build_spec=PythonBuild(command="python train.py", requirements_path="requirements.txt"),
       build_source=LocalSource(local_build=False)
   ),
)
deployment = job.deploy(workspace_fqn="YOUR WORKSPACE FQN HERE")


Het bestand requirements.txt moet de volgende packages bevatten:

requirements.txt

pandas==1.3.5
scikit-learn==1.2.1
mlfoundry>=0.7.2,<0.8.0


In de bovenstaande deploy.py-code wordt een job gedeployed die de nauwkeurigheidsscore van het getrainde model in de logs weergeeft wanneer deze wordt aangeroepen. Ook wordt het getrainde machine learning-model gelogd. Hiervoor wordt een job-object aangemaakt met behulp van de klasse servicefoundry.Job. De jobnaam is hier ingesteld op diabetes-train-job.

OPMERKING: Zorg ervoor dat je "YOUR ML REPO NAME" vervangt door jouw ML Repo Name in train.py en "YOUR WORKSPACE FQN HERE" door jouw workspace FQN in het bestand deploy.py.

In het bestand train.py moet je de Name of the ML Repo die je hebt aangemaakt doorgeven aan de functie save_model_metadata(). In het bestand deploy.py moet je de FQN van de aangemaakte workspace doorgeven aan de functie job.deploy(). Voer nu het volgende commando uit om de job te deployen:

python deploy.py


Ga na het deployen van de training job naar het onderdeel "Jobs" onder de sectie "Deployments"; het zou er ongeveer zo uit moeten zien:

Nu de deployment van onze job is afgerond, willen we deze aanroepen (triggere). Je kunt dit doen via onze Python SDK of via het TrueFoundry Dashboard. Eerst bespreken we het triggeren van jobs vanuit het TrueFoundry Dashboard. Raadpleeg de sectie Triggering Jobs from Python SDK voor andere methoden om jobs te triggeren.

Job Runs triggeren vanuit de UI

Nadat de bovenstaande training job volledig is gedeployed, ga je naar het onderdeel "Jobs" onder de sectie "Deployments". Klik op "diabetes-train-job" en klik op "Run Job" om de job te configureren voordat je deze start. Het scherm ziet er ongeveer zo uit:

Klik in het bovenstaande scherm rechtsonder op "Run Job" om deze job te starten. Nadat de training job is voltooid, ga je naar het onderdeel "Jobs" onder de sectie "Deployments" en klik je op "diabetes-train-job". Dit ziet er ongeveer zo uit:

Klik onder "Run Details" op "SVR-with-QT" om de belangrijkste metrics en hyperparameters te bekijken die in het bestand train.py zijn gelogd. Het zou er zo uit moeten zien:

Hyperparameter Tuning

Stel je voor dat je grootschalige dataverwerkings- of batchverwerkingstaken hebt waarbij het uitvoeren van een enkele job met verschillende configuraties essentieel is — niet alleen om je workflow te stroomlijnen, maar ook om consistentie in de uitvoering te garanderen. In dergelijke gevallen komt een Parameterized Job goed van pas.

Een Parameterized Job is een type job waarmee je meerdere instanties (pods) kunt aanmaken met verschillende parameters of invoerwaarden. Het hoofddoel van een Parameterized Job is het bieden van flexibiliteit bij de uitvoering van jobs door het gedrag aan te passen voor verschillende scenario's.

Een job met het commando python main.py --n_quantiles {{n_quantiles}} is bijvoorbeeld een parameterized job, omdat deze n_quantiles als invoer accepteert voor de uitvoering. We kunnen de hierboven gedeployde job vereenvoudigen door gebruik te maken van parameters.

Om de command-line argumenten te verwerken, gebruiken we de module argparse. De volgende code toont de bijgewerkte code voor de bestanden train.py en deploy.py, waarbij de standaardwaarden van kernel en n_quantiles respectievelijk linear en 100 zijn:

train.py

import os, argparse

def train(kernel, n_quantiles):
   ...

def log_model(regressor, model, X_test, y_test, ml_repo):
   ...

parser = argparse.ArgumentParser()
parser.add_argument("--kernel", default="linear", type=str)
parser.add_argument("--n_quantiles", default=100, type=int)
args = parser.parse_args()

regressor, model, X_test, y_test = train(kernel=args.kernel, n_quantiles=args.n_quantiles)
log_model(regressor, model, X_test, y_test, ml_repo=os.environ.get("ML_REPO_NAME"))


deploy.py

import argparse
from servicefoundry import Build, Job, PythonBuild, Param, LocalSource

parser = argparse.ArgumentParser()
parser.add_argument("--workspace_fqn", type=str, required=True)
parser.add_argument("--ml_repo", type=str, required=True)
args = parser.parse_args()

cmd = "python train.py --kernel {{kernel}} --n_quantiles {{n_quantiles}}"

# Defining the job specifications
# Only the command changes in 'image' attribute
job = Job(
   ...
   image=Build(build_spec=PythonBuild(command=cmd, ...), ...),
   params=[
       Param(name="n_quantiles", default='100'),
       Param(name="kernel", default='linear', description="svm kernel"),
   ],
   env={ "ML_REPO_NAME": args.ml_repo }
)
deployment = job.deploy(workspace_fqn=args.workspace_fqn)


OPMERKING: Zorg ervoor dat je "YOUR ML REPO NAME" vervangt door jouw ML Repo Name en "YOUR WORKSPACE FQN HERE" door jouw workspace FQN in het onderstaande commando.

Voer nu het volgende commando uit om de parameterized job te deployen:

python deploy.py --workspace_fqn "YOUR WORKSPACE FQN HERE" --ml_repo "YOUR ML REPO NAME"


Alternatief kun je de code rechtstreeks uitvoeren vanuit onze Github repository.

git clone https://github.com/truefoundry/truefoundry-examples.git
cd training-job-example
python deploy.py --workspace_fqn "YOUR WORKSPACE FQN HERE" --ml_repo "YOUR ML REPO NAME"


Versie 2 van de Job wordt aangemaakt zodra de deployment is voltooid. Nadat de training job volledig is gedeployed, is de volgende stap het triggeren van deze job.

Klik op de "diabetes-train-job" en klik op "Run Job" om de job te configureren voordat u deze activeert. U kunt nu de n_quantiles- en kernel-parameters wijzigen. Het zou er ongeveer zo uit moeten zien:

Probeer job runs te activeren met verschillende waarden voor de kernel-parameter, zoals linear, sigmoid, poly en rbf. op dezelfde manier kunt u verschillende waarden voor n_quantiles-parameters gebruiken, zoals 50, 80, 100, enz. Verschillende job runs zouden er ongeveer zo uit moeten zien:

Job runs vergelijken vanuit de UI

U kunt de metrics van verschillende job runs in het dashboard vergelijken door op de knop Vergelijken te klikken in het gedeelte rechtsboven op het dashboard, zoals hieronder weergegeven:

U kunt hier meer lezen over Parameterized Job Deployment:

‍

Een Job met Parameters Deployen

👍Wat u zult leren: Maak een trainingscode met de optie om hyperparameters als argumenten door te geven. Onze trainingscode deployen als een job en de argumenten toevoegen als param. Dit is een gids om trainingscode te deployen als een job via servicefoundry en verschillende hyperparameters als argumenten door te geven na deployment.Af…

TrueFoundry

‍

Job runs activeren vanuit de Python SDK

Tot nu toe hebben we het starten van job runs alleen gezien vanuit het TrueFoundry Dashboard. Nu is het mogelijk dat het starten van een job niet altijd gewenst is via de UI, dus we gaan nu bekijken hoe u een job programmatisch kunt starten via de Python SDK.

U kunt uw job programmatisch starten door de functie trigger_job te gebruiken, zoals hieronder weergegeven:

from servicefoundry import Job, trigger_job

# Configure a Job Deployment
job = Job(...)

# Deploy a Job
job_deployment = job.deploy(workspace_fqn="YOUR WORKSPACE FQN")

# Trigger/Run a Job
trigger_job(
 application_fqn=job_deployment.application_fqn,
 params={"n_quantiles":"80"}
)


Het is ook mogelijk om de application_fqn eenvoudig uit het dashboard te halen door te navigeren naar Deployments --> Jobs --> Zoek naar uw jobnaam in uw workspace (hier diabetes-train-job).

Hieronder vindt u nog een voorbeeld van het programmatisch starten van een job. Vervang eerst YOUR_APPLICATION_FQN door de Application FQN van de hierboven geïmplementeerde job in de onderstaande code. De Application FQN voor een applicatie is hieronder gemarkeerd:

In the onderstaande code kiezen we willekeurig een waarde voor modelparameters en starten we een job run met die parameters. Daarna zoeken we door job runs om de run met de maximale score te vinden. De job run met de hoogste score geeft een meer optimale keuze van modelparameters aan.

import random
import mlfoundry as mlf
from servicefoundry import trigger_job

# Find deployed job, replace with the application fqn of your job
application_fqn = "YOUR_APPLICATION_FQN"

# Randomly generate params
n_quantiles = random.randint(50, 100)
kernel_values = ['linear', 'sigmoid', 'poly', 'rbf']
kernel = kernel_values[random.randrange(0, len(kernel_values))]

# Trigger/Run a Job
triggered_job = trigger_job(
   application_fqn=application_fqn,
   params={
       "n_quantiles": str(n_quantiles),
       "kernel": kernel
   }
)
print(f'Triggered job run with n_quantiles={n_quantiles} and kernel={kernel} and name as', triggered_job.jobRunName)

client = mlf.get_client()
ml_repo_name = "YOUR ML REPO NAME HERE"
runs = client.search_runs(ml_repo=ml_repo_name)

max_score = 0
for run in runs:
   metrics = run.get_metrics()
   print(f'All Metrics for run with name as {run.run_name}":', metrics)
   if 'score' in metrics:
       max_score = max(max_score, metrics['score'][0].value)

print("Model Max Score: ", max_score)


LET OP: Zorg ervoor dat u "YOUR ML REPO NAME HERE" vervangt door uw ML Repo Name en "YOUR WORKSPACE FQN HERE" door uw workspace FQN in het onderstaande commando.

U kunt hier meer lezen over het starten van Jobs:

‍

Trigger a Job

👍Wat u zult lerenTriggeren van Jobs via Python SDK en TrueFoundry Dashboard Dit is een gids voor het triggeren van jobs via servicefoundry en...

TrueFoundry

‍

Job Runs vergelijken vanuit de Python SDK

U kunt de metrics van verschillende job runs programmatisch vergelijken door de mlfoundry.search_runs-functie te gebruiken zoals beschreven in de volgende code:

import mlfoundry as mlf

client = mlf.get_client()
ml_repo_name = "YOUR-ML-REPO-NAME"

# Returns all runs
runs = client.search_runs(ml_repo=ml_repo_name)

# Search for the subset of runs with logged accuracy metric > 0.7
filter_string = "metrics.score > 0.7"
runs = client.search_runs(ml_repo=ml_repo_name, filter_string=filter_string)


U kunt hier meer lezen over de search_runs-functie:

‍

MlFoundry

module MLFoundry functie get_clientInitialiseert en retourneert de mlfoundry client.Args: disable_analytics (bool, optional): Om uit te schakelen...

TrueFoundry

‍

Een Job Deployen met gebruik van GPU

Stel u voor dat u werkt met grootschalige modellen met miljoenen of miljarden parameters. Het trainen van zulke modellen met traditionele CPU's zou zeer tijdrovend zijn en kan zelfs onmogelijk zijn vanwege geheugenbeperkingen.

Bijvoorbeeld, het trainen van een CNN-model op basis van de CIFAR-10-dataset in een CPU-omgeving met 10 epochs duurt 36 minuten en 31 seconden, maar hetzelfde model getraind in een GPU-omgeving (NVIDIA K80) duurde slechts 4 minuten en 6 seconden. Dat is een verbetering met een factor 9x (Zie hier)

GPU's spelen een cruciale rol bij het trainen van grootschalige modellen. Ze bieden de noodzakelijke geheugenbandbreedte en parallelle verwerkingscapaciteiten om grote modelomvang en complexe architecturen efficiënt te verwerken. We leggen nu uit hoe u een GPU gebruikt in een Job.

Het gebruik van een GPU in het bovenstaande voorbeeld vereist kleine aanpassingen in de manier waarop een job is geconfigureerd in het deploy.py-bestand. De onderstaande code toont de bijgewerkte Job-configuratie voor GPU-gebruik en aangepaste CPU- en Memory-resourcetoewijzing:

deploy.py

from servicefoundry import Job, NodeSelector, GPUType, Resources

job = Job(
   resources=Resources(
       # Configure GPU
       gpu_count=1,
       node=NodeSelector(gpu_type=GPUType.T4)
       
       # (Optional) Configure CPU and Memory Resources
       cpu_request=0.2,
       cpu_limit=0.5,
       memory_request=128,
       memory_limit=512,
   ),
   ...
)


Opmerking: De rest van de code blijft ongewijzigd

Andere Job-implementatieopties

Tot nu toe hebben we verschillende Job-implementatieopties gezien, zoals image, params en env. Er zijn verschillende manieren om je job aan te passen met geavanceerde opties. Enkele daarvan zijn als volgt:

Triggertype en Concurrency instellen

Nu we Jobs hebben besproken die handmatig kunnen worden getriggerd via het TrueFoundry Dashboard of de Python SDK: wat als we willen dat een Job op een schema wordt uitgevoerd (zoals een cron job)?

Een cron job voert de gedefinieerde job uit op een herhalend schema. Dit kan nuttig zijn om een model periodiek opnieuw te trainen, rapporten te genereren en meer. We kunnen zulke jobs implementeren door hun trigger-type als volgt te wijzigen:

from servicefoundry import Job, Schedule

job = Job(
   trigger=Schedule(
     schedule="0 8 1 * *",
     concurrency_policy="Forbid" # Values: ["Forbid","Allow", "Replace"]
   ),
   concurrency_limit=3,
   ...
)


Bij cron jobs is het mogelijk dat de vorige uitvoering van de job nog niet is voltooid, terwijl het vanwege de geplande tijd alweer tijd is om de job opnieuw uit te voeren. In dergelijke gevallen kunnen we de concurrency_policy als volgt definiëren:

1. Forbid: Dit is de standaardinstelling. Geen gelijktijdige uitvoeringen toestaan.
2. Allow: Gelijktijdige uitvoeringen van jobs toestaan. Optioneel kan het maximale aantal gelijktijdig uit te voeren jobs worden gewijzigd door concurrency_limit in te stellen op de gewenste waarde.
3. Replace: Vervang de huidige job door de nieuwe.

Concurrency is niet van toepassing op handmatig getriggerde jobs. In dat geval wordt er altijd een nieuwe job-uitvoering aangemaakt.

Retries configureren

Een Job-status kan van 3 typen zijn: FINISHED, TERMINATED en FAILED. Een job kan worden geconfigureerd om het bij een fout meerdere keren opnieuw te proberen.

Een Job wordt gemarkeerd als FAILED als deze zelfs na het geconfigureerde aantal retries niet succesvol is voltooid. Retries kunnen als volgt voor een job worden geconfigureerd:

from servicefoundry import Job

job = Job(
   retries=6, # default = 1
   ...
)


Timeout configureren

In sommige use-cases moet je mogelijk opgeven wat de maximale tijd is dat een job mag blijven worden uitgevoerd.

Met timeout kun je (in seconden) de maximale uitvoeringstijd van een job opgeven, ongeacht of deze is mislukt of niet. Dit krijgt voorrang boven de retries Limit. Standaard is dit ingesteld op 1000 seconden.

Als je bijvoorbeeld de retries instelt op 6 en een timeout van 480 seconden, wordt de job na 480 seconden beëindigd, ongeacht het aantal pogingen om de job uit te voeren.

from servicefoundry import Job

job = Job(
   timeout=480,
   ...
)


Aanvullende Job-implementatieopties

Naast de Job-implementatieopties die in deze blog worden besproken, zijn er nog enkele die we niet in deze blog behandelen, zoals:

• Hoe deploy je een Job met een Pre-built Image?
• Hoe deploy je een Job met een Dockerfile?

.... en nog een paar meer. Raadpleeg onze onderstaande Documentatie om de antwoorden op de bovenstaande vragen te vinden :)

‍

Introductie

TrueFoundry is een platform op Kubernetes dat het heel eenvoudig maakt om modellen te bouwen, te tracken en te deployen zonder dat je een gedetailleerd begrip van Kubernetes hoeft te hebben. TrueFoundry wordt gehost op een cluster op je eigen cloud, zodat de data je omgeving nooit verlaat en je geen data-egress-kosten maakt.T…

TrueFoundry

‍

Aanvullende voorbeelden

Onze openbare repository truefoundry-examples bevat de broncode van de job uit deze blog en bevat ook verschillende voorbeelden, waaronder LLM Finetuning, Aan de slag met Notebooks, en End-to-End voorbeelden, die een bredere kijk geven op de functies die het TrueFoundry Platform biedt.

‍

GitHub - truefoundry/truefoundry-examples: Deze repository bevat alle projecten die in de demo-voorbeelden worden genoemd.

Deze repository bevat alle projecten die in de demo-voorbeelden worden genoemd. - GitHub - truefoundry/truefoundry-examples: Dit...

GitHub TrueFoundry

‍

Conclusie

Samengevat biedt TrueFoundry's Job een krachtig framework voor het beheren en uitvoeren van trainingstaken op een schaalbare, fouttolerante en bronefficiënte manier.

Ze stellen u in staat om de uitvoering van machine learning-workloads te distribueren en te beheren, de voortgang ervan te monitoren en ervoor te zorgen dat uw trainingsmodellen effectief en betrouwbaar worden getraind, wat ze ideaal maakt voor het uitvoeren van eenmalige of on-demand taken.