L'intelligence artificielle (IA) est devenue un sujet important et populaire dans la communauté technologique. Au fur et à mesure de l'évolution de l'IA, nous avons vu émerger différents types de modèles d'apprentissage automatique (ML). Une approche, connue sous le nom de modélisation d'ensemble, a rapidement gagné du terrain parmi les data scientists et les praticiens. Dans cet article, nous discutons de ce que sont les modèles d'ensemble et pourquoi leur utilisation peut être bénéfique. Nous fournissons ensuite un exemple de la manière dont vous pouvez entraîner, optimiser et déployer vos ensembles personnalisés à l'aide de Amazon Sage Maker.
L'apprentissage d'ensemble fait référence à l'utilisation de plusieurs modèles et algorithmes d'apprentissage pour obtenir des prédictions plus précises que n'importe quel algorithme d'apprentissage individuel. Ils se sont avérés efficaces dans diverses applications et contextes d'apprentissage tels que la cybersécurité [1] et la détection des fraudes, la télédétection, la prédiction des meilleures prochaines étapes dans la prise de décision financière, le diagnostic médical et même la vision par ordinateur et le traitement du langage naturel (PNL) Tâches. Nous avons tendance à catégoriser les ensembles selon les techniques utilisées pour les entraîner, leur composition et la manière dont ils fusionnent les différentes prédictions en une seule inférence. Ces catégories comprennent :
- Stimuler – Entraîner séquentiellement plusieurs apprenants faibles, où chaque prédiction incorrecte des apprenants précédents dans la séquence reçoit un poids plus élevé et une entrée pour l'apprenant suivant, créant ainsi un apprenant plus fort. Les exemples incluent AdaBoost, Gradient Boosting et XGBoost.
- Bagging – Utilise plusieurs modèles pour réduire la variance d'un seul modèle. Les exemples incluent Random Forest et Extra Trees.
- Empilage (mélange) – Utilise souvent des modèles hétérogènes, où les prédictions de chaque estimateur individuel sont empilées et utilisées comme données d'entrée dans un estimateur final qui gère la prédiction. Le processus de formation de cet estimateur final utilise souvent la validation croisée.
Il existe plusieurs méthodes pour combiner les prédictions en une seule que le modèle produit finalement, par exemple, en utilisant un méta-estimateur tel que l'apprenant linéaire, une méthode de vote qui utilise plusieurs modèles pour faire une prédiction basée sur le vote majoritaire pour les tâches de classification, ou un ensemble faisant la moyenne de la régression.
Bien que plusieurs bibliothèques et frameworks fournissent des implémentations de modèles d'ensemble, tels que XGBoost, CatBoost ou la forêt aléatoire de scikit-learn, dans cet article, nous nous concentrons sur l'apport de vos propres modèles et leur utilisation comme un ensemble d'empilement. Cependant, au lieu d'utiliser des ressources dédiées pour chaque modèle (tâches de formation et de réglage dédiées et points de terminaison d'hébergement par modèle), nous formons, réglons et déployons un ensemble personnalisé (plusieurs modèles) à l'aide d'une seule tâche de formation SageMaker et d'une seule tâche de réglage, et déployer sur un point de terminaison unique, réduisant ainsi les coûts éventuels et les frais généraux opérationnels.
BYOE : Apportez votre propre ensemble
Il existe plusieurs manières d'entraîner et de déployer des modèles d'ensembles hétérogènes avec SageMaker : vous pouvez entraîner chaque modèle dans un travail de formation distinct et optimiser chaque modèle séparément en utilisant Réglage automatique du modèle Amazon SageMaker. Lors de l'hébergement de ces modèles, SageMaker propose différentes manières rentables d'héberger plusieurs modèles sur la même infrastructure de locataire. Des modèles de déploiement détaillés pour ce type de paramètres sont disponibles dans Modèles d'hébergement de modèles dans Amazon SageMaker, partie 1 : modèles de conception courants pour la création d'applications ML sur Amazon SageMaker. Ces modèles incluent l'utilisation de plusieurs points de terminaison (pour chaque modèle entraîné) ou d'un seul point de terminaison multimodèle, ou même un seul point de terminaison multi-conteneurs où les conteneurs peuvent être appelés individuellement ou enchaînés dans un pipeline. Toutes ces solutions incluent un méta-estimateur (par exemple dans un AWS Lambda fonction) qui appelle chaque modèle et implémente la fonction de mélange ou de vote.
Cependant, l'exécution de plusieurs tâches de formation peut entraîner des frais généraux et des frais généraux, en particulier si votre ensemble nécessite une formation sur les mêmes données. De même, l'hébergement de différents modèles sur des points de terminaison ou des conteneurs distincts et la combinaison de leurs résultats de prédiction pour une meilleure précision nécessitent plusieurs appels, et introduisent donc des efforts supplémentaires de gestion, de coût et de surveillance. Par exemple, SageMaker prend en charge ensemble de modèles ML à l'aide de Triton Inference Server, mais cette solution nécessite que les modèles ou les ensembles de modèles soient pris en charge par le backend Triton. De plus, des efforts supplémentaires sont nécessaires de la part du client pour configurer le serveur Triton et un apprentissage supplémentaire pour comprendre le fonctionnement des différents backends Triton. Par conséquent, les clients préfèrent un moyen plus simple d'implémenter des solutions où ils n'ont besoin d'envoyer l'invocation qu'une seule fois au point de terminaison et ont la flexibilité de contrôler la façon dont les résultats sont agrégés pour générer la sortie finale.
Vue d'ensemble de la solution
Pour répondre à ces préoccupations, nous passons en revue un exemple de formation d'ensemble à l'aide d'une seule tâche de formation, en optimisant les hyperparamètres du modèle et en le déployant à l'aide d'un seul conteneur sur un point de terminaison sans serveur. Nous utilisons deux modèles pour notre pile d'ensemble : CatBoost et XGBoost (qui sont tous deux des ensembles boostés). Pour nos données, nous utilisons le ensemble de données sur le diabète [2] de la bibliothèque scikit-learn : il se compose de 10 caractéristiques (âge, sexe, masse corporelle, pression artérielle et six mesures de sérum sanguin), et notre modèle prédit la progression de la maladie 1 an après la collecte des caractéristiques de base (une régression modèle).
Le référentiel de code complet peut être trouvé sur GitHub.
Former plusieurs modèles dans une seule tâche SageMaker
Pour entraîner nos modèles, nous utilisons les tâches d'entraînement SageMaker en mode Script. Avec le mode Script, vous pouvez écrire une formation personnalisée (et plus tard du code d'inférence) tout en utilisant des conteneurs de framework SageMaker. Les conteneurs Framework vous permettent d'utiliser des environnements prêts à l'emploi gérés par AWS qui incluent tous les modules et configurations nécessaires. Pour montrer comment vous pouvez personnaliser un conteneur de framework, à titre d'exemple, nous utilisons le conteneur SKLearn pré-construit, qui n'inclut pas les packages XGBoost et CatBoost. Il existe deux options pour ajouter ces packages : soit étendre le conteneur intégré pour installer CatBoost et XGBoost (puis déployer en tant que conteneur personnalisé), ou utiliser la fonction de mode de script de tâche de formation SageMaker, qui vous permet de fournir un requirements.txt
lors de la création de l'estimateur d'entraînement. La tâche de formation SageMaker installe les bibliothèques répertoriées dans le requirements.txt
fichier pendant l'exécution. De cette façon, vous n'avez pas besoin de gérer votre propre référentiel d'images Docker et cela offre plus de flexibilité pour exécuter des scripts de formation qui nécessitent des packages Python supplémentaires.
Le bloc de code suivant montre le code que nous utilisons pour démarrer la formation. Le entry_point
paramètre pointe vers notre script de formation. Nous utilisons également deux des fonctionnalités intéressantes de l'API SageMaker SDK :
- Tout d'abord, nous spécifions le chemin local vers notre répertoire source et nos dépendances dans le
source_dir
ainsi quedependencies
paramètres, respectivement. Le SDK compressera et téléchargera ces répertoires dans Service de stockage simple Amazon (Amazon S3) et SageMaker les mettront à disposition sur l'instance de formation sous le répertoire de travail/opt/ml/code
. - Deuxièmement, nous utilisons le SDK
SKLearn
estimateur avec notre Python préféré et notre version de framework, afin que SageMaker extraie le conteneur correspondant. Nous avons également défini une métrique de formation personnalisée 'validation:rmse
', qui sera émis dans les journaux d'entraînement et capturé par SageMaker. Plus tard, nous utilisons cette métrique comme métrique objective dans la tâche de réglage.
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)
Ensuite, nous écrivons notre script de formation (multi_model_hpo.py). Notre script suit un flux simple : capturer les hyperparamètres avec lequel le travail a été configuré et former le modèle CatBoost ainsi que Modèle XGBoost. Nous mettons également en place un croix en k fonction de validation. Voir le code suivant :
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)
Une fois les modèles formés, nous calculons la moyenne des prédictions CatBoost et XGBoost. Le résultat, pred_mean
, est la prédiction finale de notre ensemble. Ensuite, nous déterminons la mean_squared_error
par rapport à l'ensemble de validation. val_rmse
est utilisé pour l'évaluation de l'ensemble pendant l'entraînement. Notez que nous imprimons également la valeur RMSE dans un modèle qui correspond à la regex que nous avons utilisée dans le metric_definitions
. Plus tard, SageMaker Automatic Model Tuning l'utilisera pour capturer la métrique objective. Voir le code suivant :
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}")
Enfin, notre script enregistre les deux artefacts de modèle dans le dossier de sortie situé à /opt/ml/model
.
Lorsqu'une tâche de formation est terminée, SageMaker regroupe et copie le contenu de la /opt/ml/model
répertoire en tant qu'objet unique au format TAR compressé vers l'emplacement S3 que vous avez spécifié dans la configuration de la tâche. Dans notre cas, SageMaker regroupe les deux modèles dans un fichier TAR et le télécharge sur Amazon S3 à la fin de la tâche de formation. Voir le code suivant :
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))
En résumé, vous devez remarquer que dans cette procédure, nous avons téléchargé les données une fois et formé deux modèles à l'aide d'une seule tâche de formation.
Réglage automatique du modèle d'ensemble
Étant donné que nous créons une collection de modèles ML, il n'est pas pratique d'explorer toutes les permutations d'hyperparamètres possibles. Offres SageMaker Réglage automatique du modèle (AMT), qui recherche les meilleurs hyperparamètres de modèle en se concentrant sur les combinaisons de valeurs les plus prometteuses dans les plages que vous spécifiez (c'est à vous de définir les bonnes plages à explorer). SageMaker prend en charge plusieurs méthodes d'optimisation pour vous de choisir.
Nous commençons par définir les deux parties du processus d'optimisation : la métrique objective et les hyperparamètres que nous voulons régler. Dans notre exemple, nous utilisons la validation RMSE comme métrique cible et nous ajustons eta
ainsi que max_depth
(pour les autres hyperparamètres, se référer à Hyperparamètres XGBoost ainsi que Hyperparamètres CatBoost):
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"
Nous devons également nous assurer dans le scénario de formation que nos hyperparamètres ne sont pas codés en dur et sont extraits des arguments d'exécution de SageMaker :
catboost_hyperparameters = {
"max_depth": args.max_depth,
"eta": args.eta,
}
SageMaker écrit également les hyperparamètres dans un fichier JSON et peut être lu à partir de /opt/ml/input/config/hyperparameters.json
sur l'instance de formation.
Comme CatBoost, nous capturons également les hyperparamètres pour le modèle XGBoost (notez que objective
ainsi que num_round
ne sont pas réglés):
catboost_hyperparameters = {
"max_depth": args.max_depth,
"eta": args.eta,
}
Enfin, nous lançons la tâche de réglage des hyperparamètres à l'aide de ces configurations :
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)
Lorsque la tâche est terminée, vous pouvez récupérer les valeurs de la meilleure tâche d'entraînement (avec un RMSE minimal) :
job_name=tuner.latest_tuning_job.name
attached_tuner = HyperparameterTuner.attach(job_name)
attached_tuner.describe()["BestTrainingJob"]
Pour plus d'informations sur l'AMT, reportez-vous à Effectuer un réglage automatique du modèle avec SageMaker.
Déploiement
Pour déployer notre ensemble personnalisé, nous devons fournir un script pour gérer la demande d'inférence et configurer l'hébergement SageMaker. Dans cet exemple, nous avons utilisé un seul fichier qui inclut à la fois le code d'apprentissage et le code d'inférence (multi_model_hpo.py). SageMaker utilise le code sous if _ name _ == "_ main _"
pour la formation et les fonctions model_fn
, input_fn
et une predict_fn
lors du déploiement et de la diffusion du modèle.
Script d'inférence
Comme pour la formation, nous utilisons le conteneur de framework SageMaker SKLearn avec notre propre script d'inférence. Le script implémentera trois méthodes requises par SageMaker.
La première, la model_fn
lit nos fichiers d'artefacts de modèles enregistrés et les charge en mémoire. Dans notre cas, la méthode renvoie notre ensemble sous la forme all_model
, qui est une liste Python, mais vous pouvez également utiliser un dictionnaire avec des noms de modèles comme clés.
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
Deuxièmement, le input_fn
La méthode désérialise les données d'entrée de la requête à transmettre à notre gestionnaire d'inférence. Pour plus d'informations sur les gestionnaires d'entrée, reportez-vous à Adapter votre propre conteneur d'inférence.
def input_fn(input_data, content_type):
dtype=None
payload = StringIO(input_data)
return np.genfromtxt(payload, dtype=dtype, delimiter=",")
Troisièmement, le predict_fn
La méthode est chargée d'obtenir des prédictions à partir des modèles. La méthode prend le modèle et les données renvoyées par input_fn
comme paramètres et renvoie la prédiction finale. Dans notre exemple, nous obtenons le résultat CatBoost à partir du premier membre de la liste de modèles (model[0]
) et le XGBoost du deuxième membre (model[1]
), et nous utilisons une fonction de fusion qui renvoie la moyenne des deux prédictions :
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)
Maintenant que nous avons nos modèles entraînés et notre script d'inférence, nous pouvons configurer l'environnement pour déployer notre ensemble.
Inférence sans serveur SageMaker
Bien qu'il y ait de nombreuses options d'hébergement dans SageMaker, dans cet exemple, nous utilisons un point de terminaison sans serveur. Les points de terminaison sans serveur lancent automatiquement les ressources de calcul et les adaptent en fonction du trafic. Cela enlève le poids indifférencié de la gestion des serveurs. Cette option est idéale pour les charges de travail qui ont des périodes d'inactivité entre les pics de trafic et qui peuvent tolérer les démarrages à froid.
La configuration du point de terminaison sans serveur est simple, car nous n'avons pas besoin de choisir les types d'instance ni de gérer les règles de mise à l'échelle. Nous n'avons besoin de fournir que deux paramètres : la taille de la mémoire et la simultanéité maximale. Le point de terminaison sans serveur attribue automatiquement des ressources de calcul proportionnelles à la mémoire que vous sélectionnez. Si vous choisissez une taille de mémoire supérieure, votre conteneur a accès à davantage de vCPU. Vous devez toujours choisir la taille de la mémoire de votre terminal en fonction de la taille de votre modèle. Le deuxième paramètre que nous devons fournir est la simultanéité maximale. Pour un point de terminaison unique, ce paramètre peut être défini jusqu'à 200 (à ce jour, la limite du nombre total de points de terminaison sans serveur dans une région est de 50). Vous devez noter que la simultanéité maximale pour un point de terminaison individuel empêche ce point de terminaison de prendre en charge toutes les invocations autorisées pour votre compte, car toutes les invocations de point de terminaison au-delà du maximum sont limitées (pour plus d'informations sur la simultanéité totale pour tous les points de terminaison sans serveur par région, consultez à Points de terminaison et quotas Amazon SageMaker).
from sagemaker.serverless.serverless_inference_config import ServerlessInferenceConfig
serverless_config = ServerlessInferenceConfig(
memory_size_in_mb=6144,
max_concurrency=1,
)
Maintenant que nous avons configuré le point de terminaison, nous pouvons enfin déployer le modèle qui a été sélectionné dans notre tâche d'optimisation des hyperparamètres :
estimator=attached_tuner.best_estimator()
predictor = estimator.deploy(serverless_inference_config=serverless_config)
Nettoyer
Même si les points de terminaison sans serveur n'ont aucun coût lorsqu'ils ne sont pas utilisés, lorsque vous avez terminé d'exécuter cet exemple, vous devez vous assurer de supprimer le point de terminaison :
predictor.delete_endpoint(predictor.endpoint)
Conclusion
Dans cet article, nous avons couvert une approche pour former, optimiser et déployer un ensemble personnalisé. Nous avons détaillé le processus d'utilisation d'une seule tâche de formation pour former plusieurs modèles, comment utiliser le réglage automatique du modèle pour optimiser les hyperparamètres d'ensemble et comment déployer un seul point de terminaison sans serveur qui mélange les inférences de plusieurs modèles.
L'utilisation de cette méthode résout les problèmes potentiels de coûts et de fonctionnement. Le coût d'une tâche de formation est basé sur les ressources que vous utilisez pendant la durée d'utilisation. En téléchargeant les données une seule fois pour former les deux modèles, nous avons réduit de moitié la phase de téléchargement des données du travail et le volume utilisé qui stocke les données, réduisant ainsi le coût global du travail de formation. De plus, la tâche AMT a exécuté quatre tâches de formation, chacune avec le temps et le stockage réduits susmentionnés, ce qui représente 4 fois les économies de coûts ! En ce qui concerne le déploiement du modèle sur un point de terminaison sans serveur, comme vous payez également pour la quantité de données traitées, en appelant le point de terminaison une seule fois pour deux modèles, vous payez la moitié des frais de données d'E/S.
Bien que cet article n'ait montré les avantages qu'avec deux modèles, vous pouvez utiliser cette méthode pour former, régler et déployer de nombreux modèles d'ensemble pour obtenir un effet encore plus important.
Bibliographie
[1] Raj Kumar, P. Arun; En ligneSelvakumar, S. (2011). "Détection d'attaques par déni de service distribué à l'aide d'un ensemble de classificateurs neuronaux". Communication informatique. 34 (11): 1328-1341. doi:10.1016/j.comcom.2011.01.012.
[2] Bradley Efron, Trevor Hastie, Iain Johnstone et Robert Tibshirani (2004) « Least Angle Regression », Annals of Statistics (avec discussion), 407-499. (https://web.stanford.edu/~hastie/Papers/LARS/LeastAngle_2002.pdf)
À propos des auteurs
Mélanie Li, PhD, est un TAM spécialiste principal de l'IA/ML chez AWS basé à Sydney, en Australie. Elle aide les entreprises clientes à créer des solutions tirant parti des outils d'IA/ML de pointe sur AWS et fournit des conseils sur l'architecture et la mise en œuvre de solutions d'apprentissage automatique avec les meilleures pratiques. Dans ses temps libres, elle aime explorer la nature à l'extérieur et passer du temps avec sa famille et ses amis.
Uri Rosenberg est le responsable technique spécialisé en IA et ML pour l'Europe, le Moyen-Orient et l'Afrique. Basé en Israël, Uri s'efforce de permettre aux entreprises clientes de concevoir, créer et exploiter des charges de travail ML à grande échelle. Dans ses temps libres, il aime faire du vélo, de la randonnée et minimiser les RMSE.
- Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
- PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
- PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
- PlatonESG. Automobile / VE, Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
- Décalages de bloc. Modernisation de la propriété des compensations environnementales. Accéder ici.
- La source: https://aws.amazon.com/blogs/machine-learning/efficiently-train-tune-and-deploy-custom-ensembles-using-amazon-sagemaker/
- :possède
- :est
- :ne pas
- :où
- ][p
- $UP
- 1
- 10
- 100
- 11
- 200
- 2011
- 50
- 60
- 7
- a
- A Propos
- accès
- Selon
- Compte
- précision
- Avec cette connaissance vient le pouvoir de prendre
- ajouter
- Supplémentaire
- En outre
- propos
- Afrique
- Après
- à opposer à
- âge
- AI
- AI / ML
- algorithme
- algorithmes
- Tous
- permis
- permet
- aussi
- toujours
- Amazon
- Amazon Sage Maker
- Amazon Web Services
- parmi
- montant
- an
- ainsi que
- tous
- applications
- une approche
- SONT
- arguments
- AS
- At
- attaquer
- Australie
- Automatique
- automatiquement
- disponibles
- moyenne
- et
- AWS
- backend
- basé
- Baseline
- BE
- car
- devenez
- était
- va
- avantageux
- avantages.
- LES MEILLEURS
- les meilleures pratiques
- Améliorée
- jusqu'à XNUMX fois
- Au-delà
- mélange
- mélanges
- Block
- sang
- Tension artérielle
- corps
- stimuler
- tous les deux
- apporter
- Apporter
- construire
- Développement
- intégré
- liasses
- mais
- by
- calculer
- CAN
- capturer
- capturé
- maisons
- catégories
- enchaîné
- des charges
- Selectionnez
- classification
- code
- du froid
- collection
- комбинации
- combinant
- Commun
- Communications
- Communautés
- irrésistible
- complet
- calcul
- ordinateur
- Vision par ordinateur
- Préoccupations
- configuration
- configurée
- consiste
- Contenant
- Conteneurs
- contenu
- des bactéries
- Correspondant
- Prix
- rentable
- couvert
- La création
- Customiser
- des clients
- Clients
- personnaliser
- Cybersécurité
- données
- La prise de décision
- dévoué
- par défaut
- Vous permet de définir
- défini
- définir
- démontrer
- Déni de service
- Selon
- déployer
- déployer
- déploiement
- Conception
- modèles de conception
- détaillé
- Détection
- Déterminer
- différent
- répertoires
- discuter
- spirituelle
- Maladie
- plusieurs
- Docker
- Ne fait pas
- Ne pas
- download
- déverser
- durée
- pendant
- chacun
- Est
- effet
- efficace
- efficacement
- efforts
- non plus
- émerger
- vous accompagner
- permettre
- fin
- Endpoint
- assurer
- Entreprise
- Environment
- environnements
- notamment
- Europe
- évaluation
- Pourtant, la
- évolué
- exemple
- exemples
- explorez
- Explorer
- supplémentaire
- famille
- Fonctionnalité
- Fonctionnalités:
- Déposez votre dernière attestation
- Fichiers
- finale
- finalement
- la traduction de documents financiers
- Prénom
- Flexibilité
- flux
- Focus
- mettant l'accent
- Abonnement
- suit
- Pour
- forêt
- le format
- trouvé
- quatre
- Framework
- cadres
- fraude
- détection de fraude
- amis
- De
- plein
- fonction
- fonctions
- En outre
- Gain
- gagner
- générer
- obtenez
- obtention
- donné
- plus grand
- l'orientation
- Half
- manipuler
- Poignées
- Vous avez
- he
- lourd
- levage de charges lourdes
- aide
- ici
- augmentation
- sa
- hôte
- hébergement
- Comment
- How To
- Cependant
- HTML
- http
- HTTPS
- Optimisation hyperparamétrique
- Réglage des hyperparamètres
- idéal
- Idle
- if
- image
- Mettre en oeuvre
- la mise en œuvre
- met en oeuvre
- important
- in
- comprendre
- inclut
- individuel
- Individuellement
- d'information
- Infrastructure
- contribution
- installer
- instance
- plutôt ;
- Intelligence
- développement
- introduire
- Introduit
- invoqué
- invoque
- Israël
- vous aider à faire face aux problèmes qui vous perturbent
- IT
- Emploi
- Emplois
- jpg
- json
- clés
- Genre
- connu
- langue
- plus importantes
- plus tard
- lancer
- apprentissage
- en tirant parti
- Li
- bibliothèques
- Bibliothèque
- lifting
- LIMIT
- Liste
- Listé
- charges
- locales
- situé
- emplacement
- enregistrement
- LOOKS
- aime
- click
- machine learning
- Entrée
- Majorité
- a prendre une
- gérer
- gérés
- gestion
- manager
- les gérer
- Masse
- maximales
- signifier
- des mesures
- médical
- membre
- Mémoire
- aller
- méthode
- méthodes
- métrique
- Milieu
- Moyen-Orient
- pourrait
- minimal
- réduisant au minimum
- ML
- Mode
- modèle
- numériques jumeaux (digital twin models)
- Modules
- Stack monitoring
- PLUS
- (en fait, presque toutes)
- plusieurs
- prénom
- noms
- Nature
- Traitement du langage naturel
- Nature
- nécessaire
- Besoin
- next
- nlp
- Remarquer..
- nombre
- nombreux
- objet
- objectif
- of
- Offres Speciales
- souvent
- on
- une fois
- ONE
- uniquement
- fonctionner
- opérationnel
- à mettre en œuvre pour gérer une entreprise rentable. Ce guide est basé sur trois décennies d'expérience
- Optimiser
- l'optimisation
- Option
- Options
- or
- OS
- Autre
- nos
- ande
- l'extérieur
- sortie
- global
- propre
- Forfaits
- paramètre
- paramètres
- partie
- les pièces
- passé
- chemin
- Patron de Couture
- motifs
- Payer
- /
- périodes
- phase
- pipeline
- Platon
- Intelligence des données Platon
- PlatonDonnées
- des notes bonus
- politiques
- Populaire
- possible
- Post
- défaillances
- pratiques
- prévoir
- prédiction
- Prédictions
- Predictor
- Prévoit
- préfère
- préféré
- la parfaite pression
- empêche
- précédent
- Imprimé
- procédure
- processus
- Traité
- traitement
- produire
- progression
- prometteur
- proven
- fournir
- fournit
- Python
- aléatoire
- rapidement
- Lire
- réduire
- Prix Réduit
- réduire
- se réfère
- Considérer
- regex
- région
- éloigné
- dépôt
- représentent
- nécessaire
- conditions
- a besoin
- Resources
- respectivement
- responsables
- résultat
- Résultats
- retourner
- Retours
- bon
- ROBERT
- Rôle
- Courir
- pour le running
- s
- sagemaker
- Réglage automatique du modèle SageMaker
- même
- Épargnez
- économie
- Escaliers intérieurs
- mise à l'échelle
- scientifiques
- scikit-apprendre
- scripts
- Sdk
- Deuxièmement
- sur le lien
- vu
- choisi
- envoyer
- supérieur
- séparé
- Séquence
- Sérum
- Sans serveur
- Serveurs
- service
- Services
- service
- set
- Paramétres
- plusieurs
- Relations sexuelles
- elle
- devrait
- montré
- Spectacles
- De même
- étapes
- unique
- SIX
- Taille
- So
- sur mesure
- Solutions
- Résout
- Identifier
- spécialiste
- groupe de neurones
- spécifié
- passer
- empiler
- empilé
- empilage
- Stanford
- Commencer
- départs
- state-of-the-art
- statistiques
- Étapes
- storage
- stockée
- STORES
- simple
- plus efficacement
- tel
- RÉSUMÉ
- Appareils
- Les soutiens
- sûr
- sydney
- prend
- prise
- Target
- tâches
- Technique
- techniques
- Technologie
- locataire
- que
- qui
- La
- leur
- Les
- puis
- Là.
- ainsi
- donc
- Ces
- l'ont
- this
- ceux
- bien que?
- trois
- Avec
- fiable
- fois
- à
- ensemble
- les outils
- sujet
- Total
- traction
- circulation
- Train
- qualifié
- Formation
- Arbres
- Trevor
- Triton
- deux
- types
- sous
- comprendre
- Utilisation
- utilisé
- d'utiliser
- Usages
- en utilisant
- validation
- Plus-value
- Valeurs
- divers
- version
- vision
- le volume
- Vote
- souhaitez
- était
- Façon..
- façons
- we
- web
- services Web
- poids
- ont été
- Quoi
- quand
- qui
- tout en
- la totalité
- why
- sera
- comprenant
- dans les
- activités principales
- de travail
- vos contrats
- écrire
- écriture
- XGBoost
- an
- Vous n'avez
- Votre
- zéphyrnet
- zéro