{"id":8066,"date":"2023-11-02T09:17:34","date_gmt":"2023-11-02T17:17:34","guid":{"rendered":"https:\/\/live-cometml.pantheonsite.io\/?p=8066"},"modified":"2025-04-24T17:04:58","modified_gmt":"2025-04-24T17:04:58","slug":"training-gradient-boosting-models-with-comet-ml","status":"publish","type":"post","link":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml\/","title":{"rendered":"Training Gradient Boosting Models With Comet ML"},"content":{"rendered":"\n
\n
\n
\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>
Photo by Diane Picchiottino<\/a> on Unsplash<\/a><\/figcaption><\/figure>\n

Introduction<\/h1>\n

Hyperparameters are among the most important aspects of any given model in Data Science and Machine Learning applications. The right combination of hyperparameters is essential when one desires to come up with a great model.<\/p>\n

A pertinent problem that plagues engineers and coders is the fact that it is difficult to get a perfect set of hyperparameters that will give the most accurate results. This problem has a fix though. If you have a set of hyperparameters with a range of values, then you could use an algorithm that attempts multiple combinations of hyperparameters and rates the performance using evaluation metrics.<\/p>\n

For this reason, multiple popular platforms and algorithms have arisen depending on the level of complexity of a problem. The variety allows someone to leverage the type of hyperparameter tuning algorithm that would computationally fit the problem at hand.<\/p>\n

Optuna vs Comet<\/h2>\n

Optuna resonates strongly with the data science and machine learning community and it is often used to look for the best hyperparameters for gradient boosting models like xgboost.<\/p>\n

Someone with experience using Optuna might find it a little difficult to use Comet<\/a> for the same objective if they have never tried using it before. Comet provides a user interface that allows someone to easily track many experiments performed for a given training session, but also provides a built-in hyperparameter optimizer.<\/p>\n

I will now get to the technical details of hyperparameter tuning and experiment tracking on comet ml by making parallels with Optuna for simple migration.<\/p>\n

Requirements<\/h2>\n

There are a few requirements that you\u2019d need before you begin:<\/p>\n

    \n
  1. A Comet ML account<\/a><\/li>\n
  2. An installation of Jupyter Notebook or a Google Colab account<\/li>\n
  3. Python 3.9.X +<\/li>\n
  4. XGBoost, Numpy, Pandas, Comet_ml and Scikit-learn libraries installed<\/li>\n
  5. Motivation to learn<\/li>\n<\/ol>\n

    Workflow Overview<\/h2>\n

    A typical Optuna workflow involves a few standard steps. You would have to first implement a normal ML workflow to train our gradient boosting model, e.g. XGBoost:<\/p>\n

      \n
    1. Import necessary libraries.<\/li>\n
    2. Define training and testing datasets.<\/li>\n
    3. Define a function to be optimized that will be used to train on different hyperparameters.<\/li>\n<\/ol>\n

      For someone familiar with Optuna, only the third step will be different and that\u2019s where we will begin:<\/p>\n

      import<\/span> optuna\nfrom<\/span> xgboost import<\/span> XGBClassifier\nfrom<\/span> optuna.integration import<\/span> XGBoostPruningCallback\n\ndef<\/span> objective<\/span>(trial<\/span>):\n   #Hyperparameters with ranges from minimum value to maximum value<\/span>\n   parameter_grid = {\n\n        \"n_estimators\"<\/span>: trial.suggest_categorical(\"n_estimators\"<\/span>, [10000<\/span>]),\n        \"learning_rate\"<\/span>: trial.suggest_float(\"learning_rate\"<\/span>, 0.01<\/span>, 0.3<\/span>),\n        \"max_leaves\"<\/span>: trial.suggest_int(\"max_leaves\"<\/span>, 20<\/span>, 3000<\/span>, step=20<\/span>),\n        \"max_depth\"<\/span>: trial.suggest_int(\"max_depth\"<\/span>, 3<\/span>, 12<\/span>),\n        \"max_bin\"<\/span>: trial.suggest_int(\"max_bin\"<\/span>, 200<\/span>, 300<\/span>),\n        \"lambda\"<\/span>: trial.suggest_int(\"lambda\"<\/span>, 0<\/span>, 100<\/span>, step=5<\/span>),\n        \"alpha\"<\/span>: trial.suggest_int(\"alpha\"<\/span>, 0<\/span>, 100<\/span>, step=5<\/span>),\n        \"gamma\"<\/span>: trial.suggest_float(\"gamma\"<\/span>, 0<\/span>, 15<\/span>),\n    }\n#feeding the hyperparameters into the model<\/span>\nmodel = XGBClassifier(objective=\"binary:logistic\"<\/span>, **parameter_grid)\n\n#Fitting<\/span>\nmodel.fit(X_train,\n          y_train,\n          eval_set=[X_test, y_test],\n          early_stopping_rounds=100<\/span>,\n          callbacks = XGBoostPruningCallback(trial, \"validation_0-logloss\"<\/span>))\n#Predict<\/span>\ny_preds = model.predict(X_test)\n\n#Creating study<\/span>\nstudy = optuna.create_study(direction=\"minimize\"<\/span>, study_name=\"Xgboost\"<\/span>)\n\n#Optimizing the study<\/span>\nstudy.optimize(objective, n_trials = 20<\/span>)\n\n#Printing the best hyperparameters<\/span>\nfor<\/span> key, value in<\/span> study.best_params.items():\n    print<\/span>(f\"\\t\\t{key}<\/span>: {value}<\/span>\"<\/span>)<\/span><\/pre>\n
      The above code snippet assumes that you already have your train and test datasets. Additionally, it gives a generalized view of the process that one undergoes when training with Optuna.<\/p>\n
      Now that we have seen a basic Optuna workflow, we can implement this in Comet ML. We will also see how we can take these results and use them in our gradient-boosting algorithm.<\/p>\n
      Comet ML Implementation<\/h2>\n
      The Comet ML Python library and Comet account are necessary to interact with the Comet API.<\/p>\n
      The first cell will include Comet ML\u2019s library call and an init method that would initialize the project:<\/p>\n
      import<\/span> comet_ml\n#Similar to the initialization of a study in Optuna<\/span>\ncomet_ml.login(project_name=\"xgboost\"<\/span>)<\/span><\/pre>\n
      Running this will then ask you for an API key that you will copy from the user settings as highlighted in the docs<\/a>.<\/p>\n
      After ensuring that your API key has been input and it accepts it as valid, the next step would be to make a similar workflow to your Optuna:<\/p>\n
        \n
      1. Place the optimization algorithm, the hyperparameters, the metric and objective in a dict and use the dict as an argument in Comet\u2019s optimizer.<\/li>\n
      2. Proceed with a normal training workflow and call the hyperparameters as arguments in the classifier.<\/li>\n
      3. Perform an experiment run that will graph the outcome in multiple experiments in Comet.<\/li>\n<\/ol>\n
        The three steps will be accompanied by code below with comparisons on how it is done in Optuna.<\/p>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
        \n
        \n
        \n
        Struggling to track and reproduce complex experiment parameters? Artifacts are just one of the many tools in the Comet toolbox to help ease model management. Read our PetCam scenario to learn more<\/a>.<\/p><\/blockquote>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
        \n
        \n
        \n
        Step 1: Dictionary for Optimizer<\/h2>\n
        The code will look as follows:<\/p>\n
        from<\/span> comet_ml import<\/span> Optimizer\n\n#Dict that contains optimization algorithm, hyperparameters,metric and objective<\/span>\nconfig = {\n    #algorithm for optimization<\/span>\n    \"algorithm\"<\/span>: \"bayes\"<\/span>,\n    #parameters<\/span>\n    \"parameters\"<\/span>:{\n        \"learning_rate\"<\/span>: {\"type\"<\/span>:\"float\"<\/span>,\"min\"<\/span>:0<\/span>, \"max\"<\/span>:1<\/span>},\n        \"max_leaves\"<\/span>: {\"type\"<\/span>:\"integer\"<\/span>, \"min\"<\/span>: 20<\/span>, \"max\"<\/span>:3000<\/span>},\n        \"max_depth\"<\/span>: {\"type\"<\/span>:\"integer\"<\/span>, \"min\"<\/span>: 3<\/span>, \"max\"<\/span>: 12<\/span>},\n        \"max_bin\"<\/span>: {\"type\"<\/span>:\"integer\"<\/span>, \"min\"<\/span>: 200<\/span>, \"max\"<\/span>: 300<\/span>},\n        \"lambda\"<\/span>: {\"type\"<\/span>:\"integer\"<\/span>, \"min\"<\/span>: 0<\/span>, \"max\"<\/span>: 100<\/span>},\n        \"alpha\"<\/span>: {\"type\"<\/span>:\"integer\"<\/span>, \"min\"<\/span>:0<\/span>, \"max\"<\/span>:100<\/span>},\n        \"gamma\"<\/span>:{\"type\"<\/span>:\"float\"<\/span>, \"min\"<\/span>:0<\/span>, \"max\"<\/span>:15<\/span>}\n    },\n    #What shall be optimized<\/span>\n    \"spec\"<\/span>:{\n        \"metric\"<\/span>: \"loss\"<\/span>,\n        \"objective\"<\/span>: \"minimize\"<\/span>\n    },\n    \"trials\"<\/span>: 1<\/span>,\n}\n#Will be used to feed information in the workflow<\/span>\nOpt_algo = Optimizer(config) <\/span><\/pre>\n
        Step 2: Normal Workflow with Comet ML integration<\/h2>\n
        Here we will split the train data and the test data. The most important thing will be the training function that introduces the hyperparameters that we want to perform multiple experiments on.<\/p>\n
        The code will be as follows:<\/p>\n
        from<\/span> xgboost import<\/span> XGBClassifier\nimport<\/span> pandas as<\/span> pd\nimport<\/span> numpy as<\/span> np\nfrom<\/span> sklearn.model_selection import<\/span> train_test_split\n\n#training dataset<\/span>\ntrain_df = pd.read_csv(\"input file path in here\"<\/span>)\n\n#Performing splits<\/span>\nX_train,  X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2<\/span>, random_state = 1<\/span>)\n\n#training function<\/span>\ndef<\/span> train_model<\/span>(experiment<\/span>):\n    model = XGBClassifier(objective=\"binary:logistic\"<\/span>,\n                           learning_rate = experiment.get_parameter(\"learning_rate\"<\/span>),\n                           max_leaves = experiment.get_parameter(\"max_leaves\"<\/span>),\n                           max_depth = experiment.get_parameter(\"max_depth\"<\/span>),\n                           max_bin = experiment.get_parameter(\"max_bin\"<\/span>),\n                           reg_lambda = experiment.get_parameter(\"lambda\"<\/span>),\n                           alpha = experiment.get_parameter(\"alpha\"<\/span>),\n                           gamma = experiment.get_parameter(\"gamma\"<\/span>))\n    model.fit(\n            X_train,\n            y_train,\n            eval_set=[(X_val, y_val)],\n            early_stopping_rounds = 100<\/span>,\n            )\n    y_pred = model.predict(X_val)<\/span><\/pre>\n
        In the above code, I would like to highlight the syntax in the XGBClassifier hyperparameters. It is not automatically obvious that the hyperparameters we used in the config dictionary correspond with those in XGBoost. Hence we need to map them with the get_parameter()<\/code> method. This is very similar to how Optuna uses trial.suggest_int()<\/code> without the difficulty of having to suggest types for those who may struggle with them.<\/p>\n
        Once we finish training then we can use this on a test set to predict its performance.<\/p>\n
        Step 3: Training Function with Comet ML page interaction<\/h2>\n
        An added benefit of using Comet is the interface that allows one to easily track the experiments they have performed and the types of hyperparameters that would produce a given set of results.<\/p>\n
        We will then call the model and put in a for loop and let it train multiple times.<\/p>\n
        for<\/span> experiment in<\/span> opt.get_experiments():\n    #Training<\/span>\n    train_model(experiment)\n    #Ending the experiment<\/span>\n    experiment.end()<\/span><\/pre>\n
        After running the above code, a project will be initialized on Comet ML<\/a>\u2019s homepage with the name you initialized with and will run multiple experiments in a short span of time. By pressing stop on the cell, one can stop further experiments from running.<\/p>\n
        As seen below:<\/p>\n
        \n
        \n
        \"\"<\/figure>
        <\/picture><\/div>\n<\/div>\n
        Screenshot by author<\/figcaption>\n<\/figure>\n
        On the right, our XGBoost project is ready and it contains the 42 experiments I ran. Clicking \u201cView Project\u201d takes you to the next page where the experiments are.<\/p>\n
        \n
        \n
        \"\"<\/figure>
        <\/picture><\/div>\n<\/div>\n
        Screenshot by author<\/figcaption>\n<\/figure>\n
        The above graph shows us the hyperparameters that led to a given loss function. As the objective was to minimize the function, we can interact with the graph and click on the lowest possible value of the loss function and extract the hyperparameters.<\/p>\n
        \n
        \n
        \"\"<\/figure>
        <\/picture><\/div>\n<\/div>\n
        Screenshot by author<\/figcaption>\n<\/figure>\n
        The experiment with the lowest possible value is named \u201creliable_aroma_2012\u201d and when we click it, we can see all the details that we seek.<\/p>\n
        \n
        \n
        \"\"<\/figure>
        <\/picture><\/div>\n<\/div>\n
        Screenshot by author<\/figcaption>\n<\/figure>\n
        And on this page, we can collect the hyperparameters that we desire and feed them into our algorithm for the performance we seek.<\/p>\n
        Conclusion<\/h1>\n
        The code above was an introduction to all parties that desire to migrate from Optuna to Comet ML for the many potential benefits that it holds. The workflow is similar when it comes to code optimization and the tweaks made will easily transition one used to Optuna to fully using Comet ML.<\/p>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
        Photo by Diane Picchiottino on Unsplash Introduction Hyperparameters are among the most important aspects of any given model in Data Science and Machine Learning applications. The right combination of hyperparameters is essential when one desires to come up with a great model. A pertinent problem that plagues engineers and coders is the fact that it […]<\/p>\n","protected":false},"author":79,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"customer_name":"","customer_description":"","customer_industry":"","customer_technologies":"","customer_logo":"","footnotes":""},"categories":[9,7],"tags":[],"coauthors":[176],"class_list":["post-8066","post","type-post","status-publish","format-standard","hentry","category-product","category-tutorials"],"yoast_head":"\nTraining Gradient Boosting Models With Comet ML - Comet<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Training Gradient Boosting Models With Comet ML\" \/>\n<meta property=\"og:description\" content=\"Photo by Diane Picchiottino on Unsplash Introduction Hyperparameters are among the most important aspects of any given model in Data Science and Machine Learning applications. The right combination of hyperparameters is essential when one desires to come up with a great model. A pertinent problem that plagues engineers and coders is the fact that it […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml\" \/>\n<meta property=\"og:site_name\" content=\"Comet\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/cometdotml\" \/>\n<meta property=\"article:published_time\" content=\"2023-11-02T17:17:34+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-04-24T17:04:58+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*jq76J8Fa50HXKw7k\" \/>\n<meta name=\"author\" content=\"Mwanikii Njagi\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@Cometml\" \/>\n<meta name=\"twitter:site\" content=\"@Cometml\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Mwanikii Njagi\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Training Gradient Boosting Models With Comet ML - Comet","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml","og_locale":"en_US","og_type":"article","og_title":"Training Gradient Boosting Models With Comet ML","og_description":"Photo by Diane Picchiottino on Unsplash Introduction Hyperparameters are among the most important aspects of any given model in Data Science and Machine Learning applications. The right combination of hyperparameters is essential when one desires to come up with a great model. A pertinent problem that plagues engineers and coders is the fact that it […]","og_url":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml","og_site_name":"Comet","article_publisher":"https:\/\/www.facebook.com\/cometdotml","article_published_time":"2023-11-02T17:17:34+00:00","article_modified_time":"2025-04-24T17:04:58+00:00","og_image":[{"url":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*jq76J8Fa50HXKw7k","type":"","width":"","height":""}],"author":"Mwanikii Njagi","twitter_card":"summary_large_image","twitter_creator":"@Cometml","twitter_site":"@Cometml","twitter_misc":{"Written by":"Mwanikii Njagi","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml#article","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml\/"},"author":{"name":"Mwanikii Njagi","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/c7043b3e6b992af7b3220aa1f27d2162"},"headline":"Training Gradient Boosting Models With Comet ML","datePublished":"2023-11-02T17:17:34+00:00","dateModified":"2025-04-24T17:04:58+00:00","mainEntityOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml\/"},"wordCount":1059,"publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*jq76J8Fa50HXKw7k","articleSection":["Product","Tutorials"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml\/","url":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml","name":"Training Gradient Boosting Models With Comet ML - Comet","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml#primaryimage"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*jq76J8Fa50HXKw7k","datePublished":"2023-11-02T17:17:34+00:00","dateModified":"2025-04-24T17:04:58+00:00","breadcrumb":{"@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml#primaryimage","url":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*jq76J8Fa50HXKw7k","contentUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*jq76J8Fa50HXKw7k"},{"@type":"BreadcrumbList","@id":"https:\/\/www.comet.com\/site\/blog\/training-gradient-boosting-models-with-comet-ml#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.comet.com\/site\/"},{"@type":"ListItem","position":2,"name":"Training Gradient Boosting Models With Comet ML"}]},{"@type":"WebSite","@id":"https:\/\/www.comet.com\/site\/#website","url":"https:\/\/www.comet.com\/site\/","name":"Comet","description":"Build Better Models Faster","publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.comet.com\/site\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.comet.com\/site\/#organization","name":"Comet ML, Inc.","alternateName":"Comet","url":"https:\/\/www.comet.com\/site\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/","url":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","contentUrl":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","width":310,"height":310,"caption":"Comet ML, Inc."},"image":{"@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/cometdotml","https:\/\/x.com\/Cometml","https:\/\/www.youtube.com\/channel\/UCmN63HKvfXSCS-UwVwmK8Hw"]},{"@type":"Person","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/c7043b3e6b992af7b3220aa1f27d2162","name":"Mwanikii Njagi","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/image\/1a3c516cf04aca9418dfb2213081f4df","url":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2023\/08\/cropped-1_2jy9gyk0G_yaniWm8gJFVA-1-96x96.webp","contentUrl":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2023\/08\/cropped-1_2jy9gyk0G_yaniWm8gJFVA-1-96x96.webp","caption":"Mwanikii Njagi"},"url":"https:\/\/www.comet.com\/site\/blog\/author\/freddynjagigmail-com\/"}]}},"_links":{"self":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/8066","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/users\/79"}],"replies":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/comments?post=8066"}],"version-history":[{"count":1,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/8066\/revisions"}],"predecessor-version":[{"id":15475,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/8066\/revisions\/15475"}],"wp:attachment":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/media?parent=8066"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/categories?post=8066"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/tags?post=8066"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/coauthors?post=8066"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}