parsnip.ParsnipModel

class parsnip.ParsnipModel(path, bands, device='cpu', threads=8, settings={}, ignore_unknown_settings=False)

Generative model of transient light curves

This class represents a generative model of transient light curves. Given a set of latent variables representing a transient, it can predict the full spectral time series of that transient. It can also use variational inference to predict the posterior distribution over the latent variables for a given light curve.

Parameters:

• path (str) – Path to where the model should be stored on disk.

• bands (List[str]) – Bands that the model uses as input for variational inference

• device (str) – PyTorch device to use for the model

• threads (int) – Number of threads to use

• settings (dict) – Settings for the model. Any settings specified here will override the defaults set in settings.py

• ignore_unknown_settings (bool) – If True, ignore any settings that are specified that are unknown. Otherwise, raise a KeyError if an unknown setting is specified. By default False.

__init__(path, bands, device='cpu', threads=8, settings={}, ignore_unknown_settings=False)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

Methods

__init__(path, bands[, device, threads, ...])	Initialize internal Module state, shared by both nn.Module and ScriptModule.
add_module(name, module)	Add a child module to the current module.
apply(fn)	Apply fn recursively to every submodule (as returned by .children()) as well as self.
augment_light_curves(light_curves[, as_table])	Augment a set of light curves
bfloat16()	Casts all floating point parameters and buffers to bfloat16 datatype.
buffers([recurse])	Return an iterator over module buffers.
children()	Return an iterator over immediate children modules.
compile(*args, **kwargs)	Compile this Module's forward using torch.compile().
cpu()	Move all model parameters and buffers to the CPU.
cuda([device])	Move all model parameters and buffers to the GPU.
decode(encoding, ref_times, color, times, ...)	Predict the light curves for a given set of latent variables
decode_spectra(encoding, phases, color[, ...])	Predict the spectra at a given set of latent variables
double()	Casts all floating point parameters and buffers to double datatype.
encode(input_data)	Predict the latent variables for a set of light curves
eval()	Set the module in evaluation mode.
extra_repr()	Return the extra representation of the module.
fit(dataset[, max_epochs, augment, test_dataset])	Fit the model to a dataset
float()	Casts all floating point parameters and buffers to float datatype.
forward(light_curves[, sample, to_numpy])	Run a set of light curves through the full ParSNIP model
get_buffer(target)	Return the buffer given by target if it exists, otherwise throw an error.
get_data_loader(dataset[, augment])	Get a PyTorch DataLoader for an lcdata Dataset
get_extra_state()	Return any extra state to include in the module's state_dict.
get_parameter(target)	Return the parameter given by target if it exists, otherwise throw an error.
get_submodule(target)	Return the submodule given by target if it exists, otherwise throw an error.
half()	Casts all floating point parameters and buffers to half datatype.
ipu([device])	Move all model parameters and buffers to the IPU.
load_state_dict(state_dict[, strict, assign])	Copy parameters and buffers from state_dict into this module and its descendants.
loss_function(result[, return_components, ...])	Compute the loss function for a set of light curves
modules()	Return an iterator over all modules in the network.
mtia([device])	Move all model parameters and buffers to the MTIA.
named_buffers([prefix, recurse, ...])	Return an iterator over module buffers, yielding both the name of the buffer as well as the buffer itself.
named_children()	Return an iterator over immediate children modules, yielding both the name of the module as well as the module itself.
named_modules([memo, prefix, remove_duplicate])	Return an iterator over all modules in the network, yielding both the name of the module as well as the module itself.
named_parameters([prefix, recurse, ...])	Return an iterator over module parameters, yielding both the name of the parameter as well as the parameter itself.
parameters([recurse])	Return an iterator over module parameters.
predict(light_curves[, augment])	Generate predictions for a light curve or set of light curves.
predict_dataset(dataset[, augment])	Generate predictions for a dataset
predict_dataset_augmented(dataset[, augments])	Generate predictions for a dataset with augmentation
predict_light_curve(light_curve[, sample, ...])	Predict the flux of a light curve on a grid
predict_redshift(light_curve[, ...])	Predict the redshift of a light curve.
predict_redshift_distribution(light_curve[, ...])	Predict the redshift distribution for a light curve.
predict_sncosmo(light_curve[, sample])	Package the predictions for a light curve as an sncosmo model
predict_spectrum(light_curve, time[, ...])	Predict the spectrum of a light curve at a given time
preprocess(dataset[, chunksize, verbose])	Preprocess an lcdata dataset
register_backward_hook(hook)	Register a backward hook on the module.
register_buffer(name, tensor[, persistent])	Add a buffer to the module.
register_forward_hook(hook, *[, prepend, ...])	Register a forward hook on the module.
register_forward_pre_hook(hook, *[, ...])	Register a forward pre-hook on the module.
register_full_backward_hook(hook[, prepend])	Register a backward hook on the module.
register_full_backward_pre_hook(hook[, prepend])	Register a backward pre-hook on the module.
register_load_state_dict_post_hook(hook)	Register a post-hook to be run after module's load_state_dict() is called.
register_load_state_dict_pre_hook(hook)	Register a pre-hook to be run before module's load_state_dict() is called.
register_module(name, module)	Alias for add_module().
register_parameter(name, param)	Add a parameter to the module.
register_state_dict_post_hook(hook)	Register a post-hook for the state_dict() method.
register_state_dict_pre_hook(hook)	Register a pre-hook for the state_dict() method.
requires_grad_([requires_grad])	Change if autograd should record operations on parameters in this module.
save()	Save the model
score(dataset[, rounds, return_components, ...])	Evaluate the loss function on a given dataset.
set_extra_state(state)	Set extra state contained in the loaded state_dict.
set_submodule(target, module[, strict])	Set the submodule given by target if it exists, otherwise throw an error.
share_memory()	See torch.Tensor.share_memory_().
state_dict(*args[, destination, prefix, ...])	Return a dictionary containing references to the whole state of the module.
to(device[, force])	Send the model to the specified device
to_empty(*, device[, recurse])	Move the parameters and buffers to the specified device without copying storage.
train([mode])	Set the module in training mode.
type(dst_type)	Casts all parameters and buffers to dst_type.
xpu([device])	Move all model parameters and buffers to the XPU.
zero_grad([set_to_none])	Reset gradients of all model parameters.

Attributes

T_destination
call_super_init
dump_patches
training