Field types

neptune.types
Types in Neptune can be separated into few categories sharing similar traits and logging/fetching methods:
​
​
Atom fields
Fields that you use to store a single value of the given type or a single file. It's possible to upload and fetchFloat, Integer, Boolean, String, Datetime and File fields. GitRef, RunState fields are possible to access, but manual creation or modification of the fields of these types is not possible.
Series fields
Fields that you use to store a series of values or a series of files (e.g. images). Available types are FloatSeries, StringSeries and FileSeries.
FileSet
Field type for holding a larger number of files, when access to a single file is rare. FileSet can be used for a folder with source files, a folder with image examples, etc. Things that can be easily browsed through the web interface, and are typically accessed as a whole.
Sets fields
Fields holding unorganized sets of values. Only one set type currenlty exists - StringSet that is used to interact with the tags of the experiment. It's possible to access it and modify it, but manual creation of the fields of this type is not possible.
Handler
When you access a run's path that doesn't exist yet you obtain a Handler object. Think of it as a wildcard that can become any of the types once you invoke on it specific logging method. If you invoke .upload() it becomes a File type, if you invoke .log(2)it will become a FloatSeries etc. Note that it can also become a Namespace handler if you create a field at a lower level of organization.
Namespace handler
If you access a run's path that is one or more levels higher than an existing field you obtain a Namespace handler object, e.g. when you access params when you have a field params/max_epochs. Namespace handler can be used as a shortcut for accessing fields by only specifying a relative path within the namespace.
Float
Field type representing a floating-point number.
=
Convenience alias for .assign(). 
.assign()
Assigns the provided value to the field.
Parameters
​
value
(float) - Value to be stored in a field.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
run = neptune.init()
3
​
4
# You can both use the Python assign operator (=)
5
run["params/lr"] = 0.8
6
# as well as directly use the .assign method
7
run["params/lr"].assign(0.8)
Copied!
.fetch()
Fetches field value from Neptune servers.
Returns
float value stored in the field.
Examples
1
import neptune.new as neptune
2
​
3
# Continue run with ID "SAN-23"
4
run = neptune.init(run="SAN-23")
5
​
6
# Fetch best accuracy so far
7
best_acc = run["train/acc/best"].fetch()
Copied!
Integer
Field type representing an integer number.
=
Convenience alias for .assign(). 
.assign()
Assigns the provided value to the field.
Parameters
​
value
(int) - Value to be stored in a field.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
run = neptune.init()
3
​
4
# You can both use the Python assign operator (=)
5
run["params/max_epochs"] = 10
6
# as well as directly use the .assign method
7
run["params/max_epochs"].assign(10)
Copied!
.fetch()
Fetches field value from Neptune servers.
Returns
int value stored in the field.
Examples
1
import neptune.new as neptune
2
​
3
# Continue run with ID "SAN-23"
4
run = neptune.init(run="SAN-23")
5
​
6
# Fetch epoch count
7
epoch = run["train/epoch"].fetch()
Copied!
Boolean
Field type representing a boolean value.
=
Convenience alias for .assign(). 
.assign()
Assigns the provided value to the field.
Parameters
​
value
(Boolean ) - Value to be stored in a field.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
run = neptune.init()
3
​
4
# You can both use the Python assign operator (=)
5
run["params/use_preprocessing"] = True
6
# as well as directly use the .assign method
7
run["params/use_preprocessing"].assign(True)
Copied!
.fetch()
Fetches field value from Neptune servers.
Returns
bool value stored in the field.
Examples
1
import neptune.new as neptune
2
​
3
# Continue run with ID "SAN-23"
4
run = neptune.init(run="SAN-23")
5
​
6
# Fetch use_proprocessing parameter
7
use_preprocessing = run['params/use_preprocessing'].fetch()
Copied!
String
Field type representing a small piece of text.
=
Convenience alias for .assign(). 
.assign()
Assigns the provided value to the field.
Parameters
​
value
(str or String ) - Value to be stored in a field.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
run = neptune.init()
3
​
4
# You can both use the Python assign operator (=)
5
run["params/optimizer"] = "Adam"
6
# as well as directly use the .assign method
7
run["params/optimizer"].assign("Adam")
Copied!
.fetch()
Fetches field value from Neptune servers.
Returns
str value stored
File
Field type for holding a single file of any type.
.upload()
Uploads provided file under specified field path
Parameters
​
value
(stror File) - Path to the file to be uploaded or File value object
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
run = neptune.init()
3
​
4
# Upload example data
5
run["dataset/data_sample"].upload("sample_data.csv")
6
​
7
# Both the content and the extension is stored
8
# When downloaded the filename is a combination of path and the extension
9
run["dataset/data_sample"].download() # data_sample.csv
10
​
11
# Explicitely create File value object
12
from neptune.new.types import File
13
run["dataset/data_sample"].upload(File("sample_data.csv"))
14
​
15
# Lot's of types will be implicitly converted to Files on the fly
16
# E.g. image-like objects such as Matplotlip figures etc.
17
import matplotlib.pyplot as plt
18
plt.plot(data)
19
run["dataset/distribution"].log(plt.gcf()) # .gcf() gets the figure object
Copied!
=
Convenience alias for .assign(). 
.assign()
You can also upload a file by assigning the File value object to the specified field path.
Parameters
​
value
(File) - File value object
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
from neptune.new.types import File
3
run = neptune.init()
4
​
5
run["dataset/data_sample"] = File("sample_data.csv")
Copied!
.download()
Downloads the stored file to the working directory or specified destination. 
Parameters
​
destination
(str, optional, default is None) - Path to where the file should be downloaded. If None file will be downloaded to the working directory.

If destination is a directory, the file will be downloaded to the specified directory with a filename composed from field name and extension (if present).
​
If destination is a path to a file, the file will be downloaded under the specified name.
.fetch_extension()
A programmatic way to discover an extension of the stored file.
Returns
Str with the extensions of the stored File.
Examples
1
import neptune.new as neptune
2
from neptune.new.types import File
3
run = neptune.init()
4
​
5
# Upload model as a File field
6
run['model/last'].upload('model.pt')
7
​
8
# Check extension of the uploaded File
9
ext = run['model/last'].fetch_extension()
10
ext == 'pt' # True
Copied!
.as_image()
Static method for converting image objects or image-like objects to an image File value object. This way you can upload Matplotlib figures, PIL images, NumPy arrays, as static images.
Parameters
​
image
Image-like object to be converted. Supported are PyTorch tensors, TensorFlow/Keras tensors, NumPy arrays, PIL images, Matplotlib figures.
Returns
File value object with converted image
Examples
1
import neptune.new as neptune
2
from neptune.new.types import File
3
run = neptune.init()
4
​
5
# Convert NumPy array to File value object and upload it
6
run["train/prediction_example"].upload(File.as_image(numpy_array))
7
​
8
# Convert PIL image to File value object and upload it
9
pil_file = File.as_image(pil_image)
10
run["dataset/data_sample/img1"].upload(pil_file)
11
​
12
# You can upload PIL image without explicit conversion
13
run["dataset/data_sample/img2"].upload(pil_image)
Copied!
.as_html()
Converts an object to an HTML File value object. This way you can upload Altair, Bokeh, Plotly, Matplotlib interactive charts or upload directly Pandas DataFrame objects to explore them in Neptune UI.
Parameters
​
value
An object to be converted. Supported are Altair, Bokeh, Plotly, Matplotlib interactive charts, and Pandas DataFrame objects.
Returns
File value object with converted object
Examples
1
import neptune.new as neptune
2
from neptune.new.types import File
3
run = neptune.init()
4
​
5
# Convert Pandas DataFrame to File value object and upload it
6
run["train/results"].upload(File.as_html(df_predictions))
7
​
8
# Convert Altair interactive chart to File value object and upload it
9
altair_file = File.as_html(altair_chart)
10
run["dataset/data_sample/img1"].upload(altair_file)
11
​
12
# You can upload Altair interactive chart without explicit conversion
13
run["dataset/data_sample/img2"].upload(altair_chart)
Copied!
.as_pickle()
Pickles a Python object and stores it in File value object. This way you can upload any Python object for future use.
Parameters
​
value
An object to be converted. Supported are Altair, Bokeh, Plotly, Matplotlib interactive charts, and Pandas DataFrame objects.
Returns
File value object with pickled object
Examples
1
import neptune.new as neptune
2
from neptune.new.types import File
3
run = neptune.init()
4
​
5
# Pickle model object and upload it
6
run["results/pickled_model"].upload(File.as_pickle(trained_model))
Copied!
.from_content()
Factory method for creating File value objects directly from binary and text content. In the case of text content, UTF-8 encoding will be used.
Parameters
​
content
(strorbytes) - Text or binary content to stored in the File value object.
extension
(str, optional, default is None) - Extension of the file created that will be used for interpreting the type of content for visualization. If None it will be bin for binary content and txt for text content.
Returns
File value object created from the content
.from_stream()
Factory method for creating File value objects directly from binary and text streams. In the case of text stream, UTF-8 encoding will be used.
Parameters
​
stream
(IOBase) - Stream to be converted.
seek
(int, optional, default is 0) - See IOBase documentation​
extension
(str, optional, default is None) - Extension of the file created that will be used for interpreting the type of content for visualization. If None it will be bin for binary stream and txt for text stream.
Returns
File value object created from the stream.
Datetime
A field representing a time. Datetime fields are possible to access, but manual creation or modification of the fields of these types is not possible.
.fetch()
Fetches field value from Neptune servers.
Returns
datetime value stored
RunState
A field containing the state of the tracked run. RunState fields are possible to access, but manual creation or modification of the fields of these types is not possible. RunState does not expose any methods.
GitRef
A field containing the information about the git repository at the time of starting the tracked run. GitRef fields are possible to access, but manual creation or modification of the fields of these types is not possible. GitRef does not expose any methods.
FloatSeries
A field containing a series of numbers for example training metrics or change of performance of the model on production. The series can be indexed both by index and by time.
.log()
Logs the provided number or a collection of numbers.
Parameters
​
value
(float or int, or collection of float or int) - The value to be logged or collections of values to be logged. If a collection is provided step and timestamp parameters must be None.
step
(float or int, optional, default is None) - Index of the log entry being appended. Must be strictly increasing. 
timestamp
(float or int, optional, default is None) - Time index of the log entry being appended in form of Unix time. If None current time (time.time()) will be used as a timestamp.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server. This makes the call synchronous, see Connection modes guide.
.fetch_last()
Fetches last value stored in the series from Neptune servers.
Returns
Last float value logged.
.fetch_values()
Fetches all values stored in the series from Neptune servers.
Parameters
​
include_timestamp
(Boolean, optional, default is True) - Whether to include the fetched data should include the timestamp field.
Returns
Pandas.DataFrame containing all the values and their indexes stored in the series field.
StringSeries
A field containing a series of text values. 
Single text log is limited to 1000 characters, but there is no limit to the number of logs in the series. If the logged text exceeds this limit it will be truncated to match it.
.log()
Logs the provided text or a collection of texts.
Parameters
​
value
(str or collection of str) - The value to be logged or collections of values to be logged. If a collection is provided step and timestamp parameters must be None.
step
(float or int, optional, default is None) - Index of the log entry being appended. Must be strictly increasing. 
timestamp
(float or int, optional, default is None) - Time index of the log entry being appended in form of Unix time. If None current time (time.time()) will be used as a timestamp.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server. This makes the call synchronous, see Connection modes guide.
.fetch_last()
Fetches last value stored in the series from Neptune servers.
Returns
Last str value logged.
.fetch_values()
Fetches all values stored in the series from Neptune servers.
Parameters
​
include_timestamp
(Boolean, optional, default is True) - Whether to include the fetched data should include the timestamp field.
Returns
Pandas.DataFrame containing all the values and their indexes stored in the series field.
FileSeries
A field containing a series of files of any type. 
We are still working on support for files of any type. In the meantime, FileSeries fields accept only image-like files.
.log()
Logs the provided file.
Parameters
​
value
(File value object or collection of File) - The file to be logged or collections of files to be logged. If a collection is provided step and timestamp parameters must be None.
step
(float or int, optional, default is None) - Index of the log entry being appended. Must be strictly increasing. 
timestamp
(float or int, optional, default is None) - Time index of the log entry being appended in form of Unix time. If None current time (time.time()) will be used as a timestamp.
name
(str, optional, default is None) - name of the logged file.
description
(str, optional, default is None) - short description of the logged file.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
from neptune.new.types import File
3
​
4
run = neptune.init()
5
​
6
# Log image file
7
run['train/prediction_example'].log(File(path_to_file))
8
​
9
# Log Matplotlib figure with implicit casting
10
run["train/distribution"].log(plt_histogram, step=epoch)
11
​
12
# This is equivalent to following explicit casting
13
run["train/distribution"].log(File.as_image(plt_histogram), step=epoch)
14
# Read more about supported conversion in File.as_image
15
​
16
# Convert NumPy array to File value object and log it
17
run["train/prediction_example"].log(File.as_image(numpy_array))
18
​
19
# You can also log name and description for the image
20
​
21
# Log data sample
22
for plt_image, class_name in data_sample:
23
    run['data/sample'].log(plt_image, name=class_name)
24
​
25
# Log predictions with class probabilities
26
for image, y_pred in zip(x_test_sample, y_test_sample_pred):
27
    description = "\n".join(
28
        ["class {}: {}".format(i, pred) for i, pred in enumerate(y_pred)]
29
    )
30
    run['train/predictions'].log(image, description=description)
Copied!
.download_last()
Downloads the last File stored in the series from Neptune servers and save it locally.
Parameters
​
destination
(str , optional, default is None) - The directory where the file will be downloaded. If None is passed, the file will be downloaded to the current working directory.

If destination is a directory, the file will be downloaded to the specified directory with a filename composed from field name and extension (if present).
​
If destination is a path to a file, the file will be downloaded under the specified name.
.download()
Downloads all files stored in the series from Neptune servers.
Parameters
​
destination
(str , optional, default is None) - The directory where the file will be downloaded. If None is passed, the file will be downloaded to the current working directory.

If destination is a directory, the file will be downloaded to the specified directory with a filename composed from field name and extension (if present).
​
If destination is a path to a file, the file will be downloaded under the specified name.
StringSet
A field containing unorganized set of strings used for interacting with your run's tags. It's possible to access it and modify it, but manual creation of new fields of this type is not possible.
.add()
Adds the provided tag or tags to the run's tags.
Parameters
​
values
(str or collection of str) - Tag or tags to be added. 

Tip: If you want you can use emojis in your tags eg. Exploration 🧪
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server first. This makes the call synchronous, see Connection modes guide.
.remove()
Removes the provided tag or tags from the set.
Parameters
​
values
(stror collection of str) - Tag or tags to be removed. 
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server first. This makes the call synchronous, see Connection modes guide.
.clear()
Removes all tags from the StringSet.
Parameters
​
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server first. This makes the call synchronous, see Connection modes guide.
.fetch()
Fetches all tags from Neptune servers.
Returns
Run's tags in a form of set of str.
FileSet
Field type for holding a larger number of files, when access to a single file is rare. FileSet can be used for a folder with source files, a folder with image examples, etc. Things that can be easily browsed through the web interface, and are typically accessed as a whole.
.upload_files()
Uploads the provided file or files and stores them inside the FileSet.
Parameters
​
globs
(stror collection of str) - Path or paths to the files to be uploaded. 
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
.delete_files()
Delete the file or files specified by paths from the FileSet stored on the Neptune servers.
Parameters
​
paths
(stror collection of str) - Path or paths to files or folders to be deleted. Note that these are paths relative to the FileSet itself e.g. if the FileSet contains file example.txt, varia/notes.txt, varia/data.csv to delete whole subfolder you would pass varia as the argument.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
.download()
Downloads all files stored in the FileSet field from Neptune servers in form of a ZIP archive.
Parameters
​
destination
(str , optional, default is None) - The directory where the files in form of a ZIP archive will be downloaded. If None is passed, the file will be downloaded to the current working directory.

If destination is a directory, the file will be downloaded to the specified directory with a filename composed from the field name and the extension.
​
If destination is a path to a file, the file will be downloaded under the specified name.
Artifact
To use artifacts you need at least 0.10.10 version of neptune client.    
1
pip install neptune-client>=0.10.10
Copied!
Field type for holding datasets, models, and other artifacts.Artifact can be used for a dataset in a CSV format, a folder with training images as PNG files, etc. You should use Artifacts for things that are large and you don't want to upload them but you would still like to version and compare them between Runs. 
=
Convenience alias for .assign(). 
.assign()
Assigns the provided value to the field.
Parameters
​
value
(str or Artifact ) - Value to be stored in a field.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
​
3
run = neptune.init(project='<YOUR_WORKSPACE/YOUR_PROJECT>',
4
                   api_token='<YOUR_API_TOKEN>')
5
​
6
run["datasets/images"].track_files("./images")
7
run["datasets/images-copy"] = run["datasets/images"].fetch()
Copied!
.download()
Downloads all the files that are referenced in the field.
Parameters
​
destination
(str , optional, default is None) - The directory where the files will be downloaded. If None is passed, the files will be downloaded to the current working directory.

If destination is a directory, the file will be downloaded to the specified directory with a filename composed from field name and extension (if present).
​
If destination is a path to a file, the file will be downloaded under the specified name.
Examples
1
import neptune.new as neptune
2
​
3
run = neptune.init(project='<YOUR_WORKSPACE/YOUR_PROJECT>',
4
                   api_token='<YOUR_API_TOKEN>',
5
                   run='AR-2', # Neptune Run ID of a run with artifact
6
                   mode='read-only')
7
​
8
run['artifacts/images'].download(destination='datasets/train/images')
Copied!
.fetch()
Fetches field value from Neptune servers. You should only use .fetch() to copy the artifact. 
Returns
Artifact object
Examples
1
import neptune.new as neptune
2
​
3
run = neptune.init(project='<YOUR_WORKSPACE/YOUR_PROJECT>',
4
                   api_token='<YOUR_API_TOKEN>')
5
​
6
run["datasets/images"].track_files("./images")
7
run["datasets/images-copy"] = run["datasets/images"].fetch()
Copied!
.fetch_files_list()
Fetches a list of artifact files from the Neptune servers.
Returns
List of ArtifactFileData objects for all the files referenced in the artifacts. 
ArtifactFileDatahas the following fields that you can use:
file_hash: str, Hash of the file
file_path: str, URL of the file in the Neptune UI
size: int,  Size of the file in KB
metadata: dict, dictionary with the following keys:
file_path: a location (path) of the file either on local storage or S3-compatible storage
last_modified: when was the last the artifact content was changed 
Examples
1
import neptune.new as neptune
2
​
3
run = neptune.init(project='<YOUR_WORKSPACE/YOUR_PROJECT>',
4
                   api_token='<YOUR_API_TOKEN>',
5
                   run='AR-2', # Neptune Run ID of a run with artifact
6
                   mode='read-only')
7
​
8
artifact_list = run['artifacts/images'].fetch_files_list()
9
artifact_list[0].file_hash
10
artifact_list[0].file_path
11
artifact_list[0].metadata['last_modified']
Copied!
.fetch_hash()
Fetches the Hash of the artifact from Neptune servers.
Returns
Hash of a Neptune artifact as astr.
Examples
1
import neptune.new as neptune
2
​
3
run = neptune.init(project='<YOUR_WORKSPACE/YOUR_PROJECT>',
4
                   api_token='<YOUR_API_TOKEN>',
5
                   run='AR-2', # Neptune Run ID of a run with artifact
6
                   mode='read-only')
7
​
8
run['artifacts/images'].fetch_hash()
Copied!
.track_files()
Saves the artifact metadata: version (hash), location (path), size, folder structure, and contents to Neptune.  Works for files, folders or S3-compatible storage. 
Parameters
​
path
(str) - File path or S3-compatible path to the file or folder that you want to track.
destination
(str, optional default is None) - location inside Neptune artifact namespace where you want to log the metadata.
wait
(Boolean, optional, default is False) - If True the client will wait to send all tracked metadata to the server before making the assignment. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
​
3
run = neptune.init(project='<YOUR_WORKSPACE/YOUR_PROJECT>',
4
                   api_token='<YOUR_API_TOKEN>')
5
​
6
run['artifacts/images'].track_files('datasets/train/images')
Copied!
The hash depends on the below:
folder/file contents,
path (local or S3 compatible), 
size, and 
last modification time. 
Any change to any of these will result in a different hash, even if the folder/file contents are exactly the same.
Namespace handler
An object representing a namespace in your run's metadata structure. You can think of namespaces as folders for organizing your metadata. When you have a fields params/max_epochs and params/lr they will be grouped under a params namespace.
Namespace handler exposes similar methods as the Run object, however, all field paths are relative to the namespace:
1
import neptune.new as neptune
2
​
3
# You can upload the value through an absolute path
4
run["params/max_epochs"] = 20
5
​
6
# Or with a relative path and a namepsace handler
7
params_ns = run["params"]
8
params_ns["max_epochs"] = 20
Copied!
[ ] (field lookup)
See Run's [] field lookup. Remember that the resulting paths will be a combination of the namespace path and the provided relative path.
=
Convenience alias for .assign(). Can be used only in combination with [] (field lookup)​
.assign()
See Run's .assign(). Remember that the resulting paths will be a combination of the namespace path and the provided relative path.
Examples
1
import neptune.new as neptune
2
run = neptune.init()
3
​
4
# Assign a single parameter
5
run["model/params/batch_size"] = 64
6
​
7
# Access params namespace handler
8
params_ns = run["model/params"]
9
​
10
# Assign additional parameters in batch
11
PARAMS = {"max_epochs": 20, "optimizer": "Adam"}
12
params_ns.assign(PARAMS)
13
​
14
# = needs to be used in combination with [] field lookup
15
params_ns = PARAMS # Does not work
16
run["model/params"] = PARAMS # Works
17
​
18
# This also works with relative pahts
19
model_ns = run["model"]
20
model_ns["params"] = PARAMS
Copied!
.fetch()
Fetch values of all non-File Atom fields as a dictionary. 
The result will preserve the hierarchical structure of the run's metadata but will contain only non-File Atom fields. You can use this method e.g. to quickly retrieve run parameters.
Returns
dict containing all non-File Atom fields values.
Examples
1
import neptune.new as neptune
2
​
3
# Resume run with SUN-123 identifier
4
run = neptune.init(project="my_workspace/my_project", run="SUN-123")
5
​
6
# Fetch the runs parameters
7
params = run["model/params"].fetch()
Copied!
Handler
When you access a run's path that doesn't exist yet you obtain a Handler object. Think of it as a wildcard that can become any of the types once you invoke on it specific logging method. If you invoke .upload() it becomes a File type, if you invoke .log(2)it will become a FloatSeries etc. Note that it can also become a Namespace handler if you create a field at a lower level of organization.
Handler object exposes all tracking methods: .assign(), .log(), .upload(), .upload_files(), etc. of all other field types as well as Namespace handler methods.
Examples
1
import neptune.new as neptune
2
run = neptune.init()
3
​
4
# Accessing "train/batch/acc" returns a Handler as the field does not exist yet
5
handler_object = run["train/batch/acc"]
6
​
7
# You can use it as if you would use any other field
8
handler_object.log(0.7)
9
​
10
# Once the field is created under the path, only the fields methods are accepted
11
handler_object.log(0.6) # Works
12
handler_object.upload("image.png") # Error, handler_object is a FloatSeries now
Copied!
API reference - Previous
Model version
Next - API reference
Management
Last modified 5mo ago