comet_ml.APIExperiment ¶

Create a new APIExperiment, or use a previous experiment key to access an existing experiment.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import comet_ml

comet_ml.login()

# Python API to create a new experiment:
experiment = comet_ml.APIExperiment(workspace=WORKSPACE,
                            project_name=PROJECT)

# Python API to access an existing experiment:
# (assumes api keys are configured):
experiment = comet_ml.APIExperiment(previous_experiment=EXPERIMENT_KEY)

Append onto an experiment's list of tags.

Parameters:

• tag (str) –

  A tag.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.add_tag("baseline")

Append onto an experiment's list of tags.

Parameters:

• tags (List[str]) –

  A list of tags (strings).

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.add_tags(["successful", "best"])

Archive this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.archive()

Create a copy of this experiment in another project in the workspace.

Parameters:

• project_name (str) –

  the name of the project with which to create a symlink to this experiment in.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.create_symlink("my-other-project")

Delete an experiment's asset.

Parameters:

• asset_id (str) –

  The asset id of the asset to delete.

Delete parameter from an experiment.

Parameters:

• parameter (str) –

  string, parameter name

>>> api_experiment.delete_parameter("learning_rate")

Delete parameter from an experiment.

Parameters:

• parameters (List[str]) –

  list of strings, parameter names

>>> api_experiment.delete_parameters(["learning_rate", "layers"])

Delete from an experiment the list of tags.

Parameters:

• tags (List[str]) –

  A list of tags (strings).

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.delete_tags(["successful", "best"])

Download and save all files from the model.

Parameters:

• name (str) –

  The name of the model.

• output_path (str, default: './' ) –

  The output directory; defaults to current directory.

• expand (bool, default: True ) –

  If True, the downloaded zipfile is unzipped; if False, then the zipfile is copied to the output_path.

Download all files logged with comet_ml.Experiment.log_tensorflow_folder.

Parameters:

• output_path (str, default: './' ) –

  Where to download the files

• overwrite (bool, default: False ) –

  If True, then overwrite any file that exists

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import comet_ml

comet_ml.login()

experiment = comet_ml.Experiment()
experiment.log_tensorboard_folder("logs")

api = comet_ml.API()
api_experiment = api.get_experiment_by_key(experiment.get_key())
api_experiment.download_tensorflow_folder()

Method called at end of experiment.

Get the associated additional system info for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_additional_system_info())

Get the artifact lineage filtered using direction parameter.

Parameters:

• direction (str, default: 'all' ) –

  String representing filtering criteria to be applied to the artifact's lineage before returning. Allowed values: 'all', 'output', or 'input'.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_artifact_lineage())

Get an asset, given the asset_id.

Parameters:

• asset_id (str) –

  The asset ID

• return_type (str, default: 'binary' ) –

  The type of object returned. Default is "binary". Options: "binary", "json", or "response"

• stream (bool, default: False ) –

  When return_type is "response", you can also use stream=True to use the response as a stream

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.get_asset("298378237283728", return_type="json")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

asset_response = api_experiment.get_asset(
    "298378237283728",
    return_type="response",
    stream=True,
)

with open(filename, 'wb') as fd:
    for chunk in asset_response.iter_content(chunk_size=1024*1024):
        fd.write(chunk)

Get an asset, given the asset filename.

Parameters:

• asset_filename (str) –

  The asset filename.

• asset_type (str, default: 'all' ) –

  Type of asset to return. Can be "all", "image", "histogram_combined_3d", "video", or "audio".

• return_type (str, default: 'binary' ) –

  The type of object returned. Default is "binary". Options: "binary", "json", or "response"

• stream (bool, default: False ) –

  When return_type is "response", you can also use stream=True to use the response as a stream

the same name. If you give the asset_type, the function will run faster. If no asset is found, then the method returns None.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.get_asset_by_name("features.json", return_type="json")

Get a list of assets associated with the experiment.

Parameters:

• asset_type (str, default: 'all' ) –

  Type of asset to return. Can be "all", "image", "histogram_combined_3d", "video", or "audio".

Returns:

• dict –

  A list of dictionaries of asset properties

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

res = api_experiment.get_asset_list()
print(res)

[{
    'fileName': 'My Filename.png',
    'fileSize': 21113,
    'runContext': None,
    'step': None,
    'link': 'https://www.comet.com/api/asset/download?experimentKey=KEY&assetId=ASSET_ID',
    'createdAt': 1565898755830,
    'dir': 'assets',
    'canView': False,
    'audio': False,
    'video': False,
    'histogram': False,
    'image': True,
    'type': 'image',
    'metadata': None,
    'assetId': ASSET_ID
},
...]

Get the associated source code for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_code())

Get the associated command-line script and args for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_command())

Get curve logged with experiment by asset id.

Parameters:

• asset_id (str) –

  The asset id of the curve to download

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.get_curve("57457745745745774")

{
    "name": "curve1",
    "x": [1, 2, 3],
    "y": [4, 5, 6], "step": 0
}

Get all curves logged with experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.get_curves()

[{
    "name": "curve1",
    "x": [1, 2, 3],
    "y": [4, 5, 6], "step": 0
}]

Deprecated. Use comet_ml.APIExperiment.get_os_packages instead.

Get the associated executable for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_executable())

Get the git-metadata associated with this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.get_git_metadata()

{
    "branch": 'refs/heads/master',
    "origin": 'git@github.com:comet-ml/comet-examples.git',
    "parent": '96ff529b4c02e4e0bb92992a7c4ce81275985764',
    "root": 'eec2d16daa057d0cf4c2c49974e6ea51e732a7b2',
    "user": 'user',
}

Get the git-patch associated with this experiment as a zipfile containing a unique file named zip_file.patch.

1
2
3
4
5
6
7
8
9

import io, zipfile
import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

zip_patch = io.BytesIO(api_experiment.get_git_patch())
archive = zipfile.ZipFile(zip_patch)
patch = archive.read("git_diff.patch")

Get the associated GPU static info for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_gpu_statis_info())

Get the associated hostname for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_hostname())

Get the HTML associated with this experiment.

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(workspace=WORKSPACE)
api_experiment.log_html("<b>Hello, world!</b>")

print(api_experiment.get_html())

Get the associated installed packages for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_installed_packages())

Get the associated IP for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_ip())

Get the associated total RAM for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_machine())

Get the associated max total memory for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_max_memory())

Get the metadata associated with this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

metadata = api_experiment.get_metadata()

{
    'archived': False,
    'durationMillis': 7,
    'endTimeMillis': 1586174765277,
    'experimentKey': 'EXPERIMENT-KEY',
    'experimentName': None,
    'fileName': None,
    'filePath': None,
    'optimizationId': None,
    'projectId': 'PROJECT-ID',
    'projectName': 'PROJECT-NAME',
    'running': False,
    'startTimeMillis': 1586174757596,
    'throttle': False,
    'workspaceName': 'WORKSPACE-NAME',
}

Get all of the logged metrics. Optionally, just get the given metric name.

Parameters:

• metric (str, default: None ) –

  If given, filter the metrics by name.

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

res = api_experiment.get_metrics()
print(res)

[{
    'metricName': 'val_loss',
    'metricValue': '0.13101346811652184',
    'timestamp': 1558962376383,
    'step': 1500,
    'epoch': None,
    'runContext': None
},
{
    'metricName': 'acc',
    'metricValue': '0.876',
    'timestamp': 1564536453647,
    'step': 100,
    'epoch': None,
    'runContext': None
},
...]

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

res = api_experiment.get_metrics("acc")
print(res)

[{
    'metricName': 'acc',
    'metricValue': '0.876',
    'timestamp': 1564536453647,
    'step': 100,
    'epoch': None,
    'runContext': None
},
...]

Return the experiment metrics summary. Optionally, also if you provide the metric name, the function will only return the summary of the metric.

Parameters:

• metric (str, default: None ) –

  Name of a metric.

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

res = api_experiment.get_metrics_summary()
print(res)

[{
    'name': 'val_loss',
    'valueMax': '0.24951280827820302',
    'valueMin': '0.13101346811652184',
    'valueCurrent': '0.13101346811652184',
    'timestampMax': 1558962367938,
    'timestampMin': 1558962367938,
    'timestampCurrent': 1558962376383,
    'stepMax': 500,
    'stepMin': 1500,
    'stepCurrent': 1500
},
...]

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

res = api_experiment.get_metrics_summary("val_loss")
print(res)

{
    'name': 'val_loss',
    'valueMax': '0.24951280827820302',
    'valueMin': '0.13101346811652184',
    'valueCurrent': '0.13101346811652184',
    'timestampMax': 1558962367938,
    'timestampMin': 1558962367938,
    'timestampCurrent': 1558962376383,
    'stepMax': 500,
    'stepMin': 1500,
    'stepCurrent': 1500
}

Get an experiment model's asset list by model name.

Parameters:

• model_name (str) –

  The name of the model.

Returns:

• dict –

  A list of asset dictionaries with these fields: fileName, fileSize, runContext, step, link, createdAt, dir, canView, audio, histogram, image, type, metadata, assetId

1
2
3
4
5
6
7
8

import comet_ml

comet_ml.login()
api = comet_ml.API()
api_exp = api.get("workspace/project/765643463546345364536453436")

res = api_exp.get_model_asset_list("Model Name")
print(res)

[
    {
        "assetId": 74374637463476,
        "audio": False,
        "canView": False,
        "createdAt": 7337347634,
        "dir": "trained-models",
        "fileName": "model.h5",
        "fileSize": 254654,
        "histogram": False,
        "image": False,
        "link": "https://link-to-download-asset-file",
        "metadata": None,
        "remote": False,
        "runContext": "train",
        "step": 54,
        "type": "asset",
    }
]

Deprecated. Use comet_ml.APIExperiment.get_model_asset_list instead.

Get the associated graph/model description for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_model_graph())

Get a list of model names associated with this experiment.

Returns:

• list –

  List of model names

Get the name of the experiment, if one.

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(workspace=WORKSPACE)
api_experiment.set_name("My Name")

print(api_experiment.get_name())

Get the associated network interface IPs for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_netword_interface_ips())

Get the associated OS for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_os())

Get the OS packages for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_os_packages())

Get the associated OS release for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_os_release())

Get the associated os type for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_os_type())

Get the other items logged in summary form.

Parameters:

• other (str, default: None ) –

  The name of the other item logged. If given, return the valueCurrent of the other item. Otherwise, return all other items logged.

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

res = api_experiment.get_others_summary()
print(res)

[{
    'name': 'trainable_params',
    'valueMax': '712723',
    'valueMin': '712723',
    'valueCurrent': '712723',
    'timestampMax': 1558962363411,
    'timestampMin': 1558962363411,
    'timestampCurrent': 1558962363411
},
...]

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

res = api_experiment.get_others_summary("trainable_params")
print(res)

['712723']

Get the associated standard output for this experiment.

1
2
3
4
5

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')
print(api_experiment.get_output())

Return the experiment parameters summary. Optionally, also if you provide a parameter name, the method will only return the summary of the given parameter.

Parameters:

• parameter (str, default: None ) –

  Name of a parameter

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_parameters_summary())

[{
    'name': 'batch_size',
    'valueMax': '120',
    'valueMin': '120',
    'valueCurrent': '120',
    'timestampMax': 1558962363411,
    'timestampMin': 1558962363411,
    'timestampCurrent': 1558962363411
},
...]

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_parameters_summary("batch_size"))

{
    'name': 'batch_size',
    'valueMax': '120',
    'valueMin': '120',
    'valueCurrent': '120',
    'timestampMax': 1558962363411,
    'timestampMin': 1558962363411,
    'timestampCurrent': 1558962363411
}

Get the pid for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_pid())

Get the associated total RAM for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_processor())

Get the Python version for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_python_version())

Get the Python version verbose for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_python_version_verbose())

Get current state of experiment.

Returns:

• str ( str ) –

  'running', 'finished' or 'crashed'

Get the system details associated with this experiment.

Returns:

• dict –

  A dictionary that follows the format:

  {
      "experimentKey": "someExperimentKey",
      "user": "system username"
      "pythonVersion": "python version"
      "pythonVersionVerbose": "python version with verbose flag"
      "pid": <Integer, pid>,
      "osType": "os experiment ran on",
      "os": "os with version info",
      "ip": "ip address",
      "hostname": "hostname",
      "gpuStaticInfoList": [
          {
          "gpuIndex": <Integer, index>,
          "name": "name",
          "uuid": "someUniqueId",
          "totalMemory": <Integer, total memory>,
          "powerLimit": <Integer, max power>
          }
      ],
      "logAdditionalSystemInfoList": [
          {
          "key": "someKey",
          "value": "someValue"
          }
      ],
      "systemMetricNames": ["name", "anotherName"],
      "maxTotalMemory": <double, max memory used>,
      "networkInterfaceIps": ["ip", "anotherIp"]
      "command": ["part1", "part2"],
      "executable": "The python Exe, if any (in future could be non python executables)",
      "osPackages": ["package", "anotherPackage"],
      "installedPackages": ["package", "anotherPackage"]
  }
  

Get the associated system metric names for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_system_metric_names())

Get the associated tags for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_tags())

Get the associated total RAM for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_total_memory())

Get the associated user for this experiment.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

print(api_experiment.get_user())

Log additional system information for this experiment.

Parameters:

• key (str) –

  The name for this system information.

• value (Any) –

  The value of the system information.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

experiment.log_additional_system_info("some name": 42)

Upload an asset to an experiment.

Parameters:

• filename (str) –

  The name of the asset file to upload.

• step (int, default: None ) –

  The current step.

• overwrite (bool, default: None ) –

  If True, overwrite any previous upload.

• context (str, default: None ) –

  The current context (e.g., "train" or "test").

• ftype (str, default: None ) –

  the type of asset (e.g., "image", "histogram_combined_3d", "image", "audio", or "video").

• metadata (dict, default: None ) –

  a JSON object to attach to image.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_asset("histogram.json", ftype="histogram_compbined_3d")

Log an instance of cpu_metrics.

Parameters:

• cpu_metrics (list) –

  A list of integer percentages, ordered by cpu.

• context (str, default: None ) –

  A run context.

• step (int, default: None ) –

  The current step.

• epoch (int, default: None ) –

  The current epoch.

• timestamp (int, default: None ) –

  Current time, in milliseconds.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_cpu_metrics([25, 50, 10, 45])

Log timeseries data.

Parameters:

• name (str) –

  Name of data.

• x (list) –

  List of x-axis values.

• y (list) –

  List of y-axis values.

• overwrite (bool, default: False ) –

  If True, overwrite previous log.

• step (int, default: None ) –

  The step value

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

experiment.log_curve("my curve", x=[1, 2, 3, 4, 5],
                                 y=[10, 20, 30, 40, 50])

Log an instance of gpu_metrics.

Parameters:

• gpu_metrics (list) –

  A list of dicts with keys:

  • gpuId: required, Int identifier
  • freeMemory: required, Long
  • usedMemory: required, Long
  • gpuUtilization: required, Int percentage utilization
  • totalMemory: required, Long

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_gpu_metrics([{
    "gpuId": 1,
    "freeMemory": 1024,
    "usedMemory": 856,
    "gpuUtilization": 25,
    "totalMemory": 2056,
}])

Set, or append onto, an experiment's HTML.

Parameters:

• html (str) –

  The HTML text to associate with this experiment.

• clear (bool, default: False ) –

  If True, clear any previously logged HTML.

• timestamp (int, default: None ) –

  The current time (in milliseconds).

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_html("<b>Hello!</b>")

Upload an image asset to an experiment.

Parameters:

• filename (str) –

  The name of the image file to upload.

• image_name (str, default: None ) –

  The name of the image.

• step (int, default: None ) –

  The current step.

• overwrite (bool, default: None ) –

  If True, overwrite any previous upload.

• context (str, default: None ) –

  The current context (e.g., "train" or "test").

• metadata (dict, default: None ) –

  Some additional data to attach to the image. Must be a JSON-compatible dict.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_image("image.png", "Weights")

Log an instance of system load metrics.

Parameters:

• load_avg (float) –

  The load average.

• context (str, default: None ) –

  The run context.

• step (int, default: None ) –

  The current step.

• epoch (int, default: None ) –

  The current epoch.

• timestamp (int, default: None ) –

  The current timestamp in milliseconds.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_load_metrics(1.5, "validate", 100, 25, 65364346)

Set a metric name/value pair for an experiment.

Parameters:

• metric (str) –

  The name of the metric.

• value (Any) –

  The value of the metric.

• step (int, default: None ) –

  The current step.

• epoch (int, default: None ) –

  The current epoch.

• timestamp (int, default: None ) –

  The current timestamp in seconds.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_metric("loss", 0.698)

Set a dictionary of metric name/value pairs for an experiment.

Parameters:

• metric_dict (dict) –

  A dict in the form of {"metric_name": value, ...}.

• step (int, default: None ) –

  The current step.

• epoch (int, default: None ) –

  The current epoch.

• timestamp (int, default: None ) –

  The current timestamp in milliseconds.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_metrics({"loss": 0.698, "accuracy": 0.12})

Set another key/value pair for an experiment.

Parameters:

• key (str) –

  The name of the other information.

• value (Any) –

  The value of the other information.

• timestamp (int, default: None ) –

  optional, the current timestamp in milliseconds.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_other("key", value)

Log output line(s).

Parameters:

• output (str) –

  String representing standard output or error.

• context (str, default: None ) –

  The run context.

• stderr (bool, default: False ) –

  If True, the lines are standard errors

• timestamp (int, default: None ) –

  The current timestamp in milliseconds

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_output("output line 1\noutput line 2")

Set a parameter name/value pair for an experiment.

Parameters:

• parameter (str) –

  The name of the parameter.

• value (Any) –

  The value of the parameter.

• step (int, default: None ) –

  The current step.

• timestamp (int, default: None ) –

  The current timestamp in milliseconds.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_parameter("hidden_layer_size", 64)

Set a dictionary of parameter name/value pairs for an experiment.

Parameters:

• param_dict (dict) –

  Dict in the form of {"param_name": value, ...}.

• step (int, default: None ) –

  The current step.

• timestamp (int, default: None ) –

  The current timestamp in milliseconds.

• nested_support (bool, default: True ) –

  Support nested parameters.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_parameters({"learning_rate": 0.12, "layers": 3})

Log an instance of RAM metrics.

Parameters:

• total_ram (float) –

  Total RAM available.

• used_ram (float) –

  RAM used.

• context (str, default: None ) –

  The run context.

• step (int, default: None ) –

  The current step.

• epoch (int, default: None ) –

  The current epoch.

• timestamp (int, default: None ) –

  The current timestamp in millisconds.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_ram_metrics(1024, 865, "train", 100, 1, 3645346534)

Log tabular data, including data, csv files, tsv files, and Pandas dataframes.

Parameters:

• filename (str) –

  A filename ending in ".csv", or ".tsv" (for tablular data) or ".json", ".csv", ".md", or ".html" (for Pandas dataframe data).

• tabular_data (Any, default: None ) –

  Data that can be interpreted as 2D tabular data or a Pandas dataframe.

• headers (bool | list, default: False ) –

  If True, will add column headers automatically if tabular_data is given; if False, no headers will be added; if list then it will be used as headers. Only useful with tabular data (csv, or tsv).

• format_kwargs (Any, default: {} ) –

  When passed a Pandas dataframe these keyword arguments are used in the conversion to "json", "csv", "md", or "html". See Pandas Dataframe conversion methods (like to_json()) for more information.

See also:

• pandas.DataFrame.to_json documentation
• pandas.DataFrame.to_csv documentation
• pandas.DataFrame.to_html documentation
• pandas.DataFrame.to_markdown documentation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_table("vectors.tsv",
                         [["one", "two", "three"],
                         [1, 2, 3],
                         [4, 5, 6]])

api_experiment.log_table("dataframe.json", pandas_dataframe)

Logs the video to Comet. Videos are displayed on the assets tab in Comet and support the following formats: MP4, MOV, WMV, and GIF.

Parameters:

• filename (str) –

  The path to the video file.

• name (str, default: None ) –

  A custom name can be provided to be displayed on the assets tab. If not provided, the filename from the file argument will be used if it is a path.

• overwrite (bool, default: False ) –

  If another video with the same name exists, it will be overwritten if overwrite is set to True.

• step (int, default: None ) –

  This is used to associate the video asset with a specific step.

• epoch (int, default: None ) –

  Used to associate the asset to a specific epoch.

• context (str, default: None ) –

  The current context (e.g., "train" or "test")

• metadata (dict, default: None ) –

  Additional custom metadata can be associated with the logged video.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.log_video("video.mp4")

Register an experiment model in the workspace registry.

Parameters:

• model_name (str) –

  The name of the experiment model.

• workspace (str, default: None ) –

  This argument is deprecated and ignored.

• version (str, default: None ) –

  A proper semantic version string; defaults to "1.0.0".

• registry_name (str, default: None ) –

  The name of the registered workspace model, if not provided the model_name will be used instead.

• public (bool, default: None ) –

  If True, then the model will be publically viewable.

• description (str, default: None ) –

  A textual description of the model.

• comment (str, default: None ) –

  A textual comment about the model.

• tags (Any, default: None ) –

  A list of textual tags such as ["tag1", "tag2"], etc.

• stages (Any, default: None ) –

  Equivalent to tags, DEPRECATED with newer backend versions.

• status (str, default: None ) –

  Allowed values are configured at the organization level.

Returns:

• dict –

  if successful, the dict will looks like this:

  {"registryModelId": "ath6ho4eijaexeShahJ9sohQu", "registryModelItemId": "yoi5saes7ea2vooG2ush1uuwi"}
  

Set the code for this experiment. Pass in either the code as a string, or provide filename.

Parameters:

• code (str, default: None ) –

  The source code for this experiment

• filename (str, default: None ) –

  The filename for this experiment

1
2
3
4
5
6
7

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.set_code("import comet_ml\nexperiment = comet_ml.Experiment()")
api_experiment.set_code(filename="script.py")

Set the command-line (script and args) for this experiment.

Parameters:

• command_args_list (List[str]) –

  Starting with name of script, and followed by arguments.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.set_command(["script.py", "arg1", "arg2", "--flag", "arg3"])

Set the end time of an experiment.

Parameters:

• end_server_timestamp (int) –

  A timestamp in milliseconds

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.set_end_time(2652656352)

Set the executable for this experiment.

Parameters:

• executable (str) –

  The python executable.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.set_executable("/usr/bin/python3")

Set the path and filename for this experiment.

Parameters:

• filename (str) –

  The python path and filename.

1
2
3
4
5
6

import comet_ml

comet_ml.login()
api_experiment = comet_ml.APIExperiment(previous_experiment='EXPERIMENT-KEY')

api_experiment.set_filename("../src/script.py")