{"id":7421,"date":"2023-09-11T10:00:27","date_gmt":"2023-09-11T18:00:27","guid":{"rendered":"https:\/\/live-cometml.pantheonsite.io\/?p=7421"},"modified":"2025-04-24T17:14:12","modified_gmt":"2025-04-24T17:14:12","slug":"an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2","status":"publish","type":"post","link":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/","title":{"rendered":"An End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2"},"content":{"rendered":"\n\n\n\n\n
\n
\n
\n
\n
\n
\"\"<\/figure>
<\/picture><\/div>\n<\/div>
Photo by Maxim Hopman<\/a> on Unsplash<\/a><\/figcaption><\/figure>\n

In the first part of this article<\/strong><\/a>, we made a point to go through the steps that are necessary for you to log a model into the registry. This was necessary as the registry is where a machine learning practitioner can keep track of experiments and model versions.<\/p>\n

The next step that I will address in this article involves the development of different models. Additionally, they will have a better performance than the one that had initially been logged. It is necessary as one can easily trace where performance increases and performance drops occur.<\/p>\n

Workflow<\/h2>\n

The workflow will primarily be derived from what we did in the previous article. If we have a better-performing model than the previous one, we can keep it to improve the performance on test datasets. There will be no additional libraries and requirements. To review part one of this series, or to set up your environment for this workflow, check out my article below:<\/p>\n

\n
\n
\n

An End-to-End Guide on Using Comet ML\u2019s Model Versioning Feature: Part 1<\/h2>\n
\n

First-time project and model registration<\/h3>\n<\/div>\n
\n

heartbeat.comet.ml<\/p>\n<\/div>\n<\/div>\n

\n
<\/div>\n<\/div>\n<\/div>\n<\/div>\n

Steps that we will follow:<\/p>\n

    \n
  1. Evaluating the performance of different models.<\/li>\n
  2. Setting up an experiment in our project and using its path to come up with a newer version of our model in the model registry of the initial model.<\/li>\n
  3. Naming our new model and seeing how we can interact with it.<\/li>\n<\/ol>\n

    Comparing model performance<\/h2>\n

    Different models offer varying levels of performance on a given dataset because of their inherent strengths and weaknesses. Sometimes this is a good thing as it may be beneficial to the outcome that a data scientist or machine learning practitioner may desire.<\/p>\n

    Let\u2019s get to the code:<\/p>\n

    import<\/span> numpy as<\/span> np\nfrom<\/span> sklearn.model_selection import<\/span> cross_val_score\nfrom<\/span> sklearn.neighbors import<\/span> KNeighborsClassifier\nfrom<\/span> sklearn.tree import<\/span> DecisionTreeClassifier\nfrom<\/span> xgboost import<\/span> XGBClassifier\nfrom<\/span> sklearn.neural_network import<\/span> MLPClassifier\nfrom<\/span> sklearn.model_selection import<\/span> StratifiedKFold\nfrom<\/span> sklearn.linear_model import<\/span> LogisticRegression\nfrom<\/span> sklearn.ensemble import<\/span> RandomForestClassifier\n\n#Passing all the algorithms in a dict<\/span>\nmodels = { 'knc'<\/span> : KNeighborsClassifier(),\n           'dtc'<\/span> : DecisionTreeClassifier(),\n           'xgc'<\/span> : XGBClassifier(),\n           'mlp'<\/span> : MLPClassifier(max_iter=1000<\/span>, random_state = 0<\/span>),\n           'lr'<\/span>  : LogisticRegression(max_iter=500<\/span>),\n           'rf'<\/span>  : RandomForestClassifier()\n         }\n#Function to calculate the cross validation score<\/span>\ndef<\/span> cross_val_eval<\/span>(model, X, y<\/span>):\n    cv = StratifiedKFold(n_splits=5<\/span>, shuffle=True<\/span>, random_state=5<\/span>)\n    cv_scores = cross_val_score(model, X, y, cv = cv, scoring='accuracy'<\/span>, n_jobs=-1<\/span>, error_score='raise'<\/span>)\n    return<\/span> cv_scores\n\n#passing the model_dict function into a variable<\/span>\nmodels = model_dict()\n\n#Performance evaluation<\/span>\nresults, names = list<\/span>(), list<\/span>()\nfor<\/span> name, model in<\/span> models.items():\n    scores = cross_val_eval(model, X, y)\n    results.append(scores)\n    names.append(names)\n    print<\/span>('%s %.5f (%.3f)'<\/span> % (name, np.mean(scores), np.std(scores)))<\/span><\/pre>\n
    The above code evaluates the performance of different algorithms that are in the dictionary and the result is shown below:<\/p>\n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    From the above image, the best-performing algorithms are MLPClassifier and Logistic Regression as they have the highest accuracy and the same standard deviation.<\/p>\n
    Picking either of them could allow for a better-performing model in comparison to the one that we had in the previous article. So I will pick the MLPClassifier algorithm for the next model.<\/p>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    \n
    Have you tried Comet? Sign up for free and easily track experiments, manage models in production, and visualize your model performance<\/a>.<\/p><\/blockquote>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    \n
    2. Setting up an experiment and registering the model<\/h2>\n
    As we are performing model versioning then we need to make sure that all of our experiments are in the same Project and models in the same Registry.<\/p>\n
    From the first article, we have our Project named model-tracking<\/code> where we ran an experiment with our first project that Comet automatically named intact_silo_3082<\/code>.<\/p>\n
    Your project view should look as follows:<\/p>\n
    \n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n<\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    When we click the \u201cView Project button\u201d (under \u201cUncategorized Experiments), then we will see our only (previous) experiment:<\/p>\n
    \n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n<\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    Our objective is to add a new model to the registry so the first step would be to ensure we have it running as an experiment in the above project. So we will write our code as follows:<\/p>\n
    #our new better performing algorithm<\/span>\nmodel1 = MLPClassifier(max_iter=1000, random_state = 0)\n\n#fitting model<\/span>\nmodel1.fit(X, y)\n\n#exporting model to desired location<\/span>\ndump(model1, \"model1.joblib\"<\/span>)<\/span><\/pre>\n
    The next step would be to import Comet ML\u2019s library to log the experiment under this project.<\/p>\n
    from<\/span> comet_ml import<\/span> API, Experiment\nexperiment = Experiment()\napi = API()\n\n#naming the model \"model1\" and highlighting where it is stored in the computer<\/span>\nexperiment.log_model(\"model1\"<\/span>, \"\/home\/mwaniki-new\/Documents\/Stacking\/model1.joblib\"<\/span>)\nexperiment.end()<\/span><\/pre>\n
    Make sure to end your experiment with experiment.end()<\/code> to prevent it from running perpetually and to finalizing all logging to the UI.<\/p>\n
    After we run the above code, we will have a new experiment logged and now we can use its path to register a new version of our model in the model registry.<\/p>\n
    \n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n<\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    In the above screenshot, our new experiment is named intact_krill_7478<\/code> and when we click it, we\u2019ll be able to copy the path from the top.<\/p>\n
    \n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n<\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    We will then use the above path to register the new version of our model after copying it.<\/p>\n
    3. Adding the model to the registry<\/h2>\n
    \n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n<\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    Our model will already have version 1.0.0 that we made in the previous article. We will now add our newer version and name it 1.1.0 and view it from this page.<\/p>\n
    experiment = api.get(\"mwanikinjagi\/model-tracking\/intact_krill_7478\"<\/span>)\nexperiment.register_model(model_name=\"model1\"<\/span>, version=\"1.1.0\"<\/span>)\nexperiment.end()<\/span><\/pre>\n
    In the above code, we add our newer version model to the \u201cmodel1\u201d page that we have in the registry. The first action performed is pasting the path copied above into the \u201capi.get()\u201d method.<\/p>\n
    We then specify the model_name as \u201cmodel_1\u201d and name it \u201c1.1.0\u201d. The model registry page should then appear as it is below:<\/p>\n
    \n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n<\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    We can now see that the model has two versions. The next step would be to click \u201cView Model.\u201d<\/p>\n
    \n
    \n
    \"\"<\/figure>
    <\/picture><\/div>\n<\/div>\n
    Screenshot by author<\/figcaption>\n<\/figure>\n
    The above screen appears. We can see our first and second models and their version names. On the far right, we have their source experiments that appear on the Project page.<\/p>\n
    Additionally, anyone with access to the workspace can download the models and begin utilizing them as it has already been uploaded to the registry.<\/p>\n
    Wrap up<\/h2>\n
    This marks the end of the two-article series explaining how someone can track a model and its development using Comet ML. We have demonstrated that it is possible to develop a better model and keep track of its versions through the entire development process.<\/p>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
    Photo by Maxim Hopman on Unsplash In the first part of this article, we made a point to go through the steps that are necessary for you to log a model into the registry. This was necessary as the registry is where a machine learning practitioner can keep track of experiments and model versions. The […]<\/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":[6,7],"tags":[],"coauthors":[176],"class_list":["post-7421","post","type-post","status-publish","format-standard","hentry","category-machine-learning","category-tutorials"],"yoast_head":"\nAn End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2 - 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\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"An End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2\" \/>\n<meta property=\"og:description\" content=\"Photo by Maxim Hopman on Unsplash In the first part of this article, we made a point to go through the steps that are necessary for you to log a model into the registry. This was necessary as the registry is where a machine learning practitioner can keep track of experiments and model versions. The […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/\" \/>\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-09-11T18:00:27+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-04-24T17:14:12+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*RzaaZaQz9f-CJAHd\" \/>\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=\"7 minutes\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"An End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2 - 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\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/","og_locale":"en_US","og_type":"article","og_title":"An End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2","og_description":"Photo by Maxim Hopman on Unsplash In the first part of this article, we made a point to go through the steps that are necessary for you to log a model into the registry. This was necessary as the registry is where a machine learning practitioner can keep track of experiments and model versions. The […]","og_url":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/","og_site_name":"Comet","article_publisher":"https:\/\/www.facebook.com\/cometdotml","article_published_time":"2023-09-11T18:00:27+00:00","article_modified_time":"2025-04-24T17:14:12+00:00","og_image":[{"url":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*RzaaZaQz9f-CJAHd","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":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/#article","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/"},"author":{"name":"Mwanikii Njagi","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/c7043b3e6b992af7b3220aa1f27d2162"},"headline":"An End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2","datePublished":"2023-09-11T18:00:27+00:00","dateModified":"2025-04-24T17:14:12+00:00","mainEntityOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/"},"wordCount":868,"publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*RzaaZaQz9f-CJAHd","articleSection":["Machine Learning","Tutorials"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/","url":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/","name":"An End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2 - Comet","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/#primaryimage"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*RzaaZaQz9f-CJAHd","datePublished":"2023-09-11T18:00:27+00:00","dateModified":"2025-04-24T17:14:12+00:00","breadcrumb":{"@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/#primaryimage","url":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*RzaaZaQz9f-CJAHd","contentUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/0*RzaaZaQz9f-CJAHd"},{"@type":"BreadcrumbList","@id":"https:\/\/www.comet.com\/site\/blog\/an-end-to-end-guide-to-using-comet-mls-model-versioning-feature-part-2\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.comet.com\/site\/"},{"@type":"ListItem","position":2,"name":"An End-to-End Guide to Using Comet ML\u2019s Model Versioning Feature: Part 2"}]},{"@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\/7421","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=7421"}],"version-history":[{"count":1,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7421\/revisions"}],"predecessor-version":[{"id":15549,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7421\/revisions\/15549"}],"wp:attachment":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/media?parent=7421"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/categories?post=7421"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/tags?post=7421"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/coauthors?post=7421"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}