def _create_or_get_experiment2(self):
"""
Super bad !!! Dont do this
"""
proxies = {
'http': 'http://proxy.ethz.ch:3128',
'https': 'http://proxy.ethz.ch:3128',
}
if self.offline_mode:
project = neptune.Session(
backend=neptune.OfflineBackend()).get_project('dry-run/project')
else:
#project_qualified_name='jonasfrey96/ASL', api_token=os.environ["NEPTUNE_API_TOKEN"], proxies=proxies
session = neptune.init(project_qualified_name='jonasfrey96/ASL',
api_token=self.api_key,
proxies=proxies) # add your credential
print(type(session))
session = neptune.Session(api_token=self.api_key, proxies=proxies)
project = session.get_project(self.project_name)
if self.experiment_id is None:
e = project.create_experiment(name=self.experiment_name,
**self._kwargs)
self.experiment_id = e.id
else:
e = project.get_experiments(id=self.experiment_id)[0]
self.experiment_name = e.get_system_properties()['name']
self.params = e.get_parameters()
self.properties = e.get_properties()
self.tags = e.get_tags()
return e
def __init__(
self,
project_qualified_name: Optional[str] = None,
api_token: Optional[str] = None,
offline: bool = False,
experiment_id: Optional[int] = None,
experiment_name: Optional[str] = None,
tags: Optional[Collection[str]] = None,
):
"""Initialize the Neptune result tracker.
:param project_qualified_name:
Qualified name of a project in a form of ``namespace/project_name``.
If ``None``, the value of ``NEPTUNE_PROJECT`` environment variable will be taken. For testing,
should be `<your username>/sandbox`
:param api_token:
User's API token. If ``None``, the value of ``NEPTUNE_API_TOKEN`` environment variable will be taken.
.. note::
It is strongly recommended to use ``NEPTUNE_API_TOKEN`` environment variable rather than
placing your API token in plain text in your source code.
:param offline:
Run neptune in offline mode (uses :class:`neptune.OfflineBackend` as the backend)
:param experiment_id:
The identifier of a pre-existing experiment to use. If not given, will rely
on the ``experiment_name``.
:param experiment_name:
The name of the experiment. If no ``experiment_id`` is given, one will be created based
on the name.
:param tags: A collection of tags to add to the experiment
"""
import neptune
if offline:
self.session = neptune.Session(backend=neptune.OfflineBackend())
else:
self.session = neptune.Session.with_default_backend(
api_token=api_token)
self.project = self.session.get_project(project_qualified_name)
if experiment_id is None and experiment_name is None:
raise ValueError(
'need experiment_name if no experiment_id is given')
if experiment_id is None:
self.experiment = self.project.create_experiment(
name=experiment_name)
else:
self.experiment = self.project.get_experiments(id=experiment_id)[0]
if tags:
self.experiment.append_tags(*tags)
def _create_or_get_experiment(self):
if self.offline_mode:
project = neptune.Session(backend=neptune.OfflineBackend()
).get_project('dry-run/project')
else:
session = neptune.Session.with_default_backend(
api_token=self.api_key)
project = session.get_project(self.project_name)
if self._experiment_id is None:
exp = project.create_experiment(name=self.experiment_name,
**self._kwargs)
else:
exp = project.get_experiments(id=self._experiment_id)[0]
self._experiment_id = exp.id
return exp
def _create_or_get_experiment(self):
if self.offline_mode:
project = neptune.Session(backend=neptune.OfflineBackend()).get_project('dry-run/project')
else:
session = neptune.Session.with_default_backend(api_token=self.api_key)
project = session.get_project(self.project_name)
if self.experiment_id is None:
exp = project.create_experiment(name=self.experiment_name, **self._kwargs)
self.experiment_id = exp.id
else:
exp = project.get_experiments(id=self.experiment_id)[0]
self.experiment_name = exp.get_system_properties()['name']
self.params = exp.get_parameters()
self.properties = exp.get_properties()
self.tags = exp.get_tags()
return exp
def configure_neptune_exp(name):
global _NEPTUNE
if 'NEPTUNE_TOKEN' not in os.environ:
logger.warning(
"Neptune couldn't be configured. Couldn't find NEPTUNE_TOKEN. ")
return
NEPTUNE_TOKEN = os.environ['NEPTUNE_TOKEN']
NEPTUNE_USER = os.environ['NEPTUNE_USER']
NEPTUNE_PROJECT = os.environ['NEPTUNE_PROJECT']
C = copy.deepcopy(_CONFIG)
C = {k[1].split(".")[-1]: v
for k, v in C.items()} # Hacky way to simplify config
logger.info("Initializing neptune to name " + name)
project = neptune.Session(NEPTUNE_TOKEN).get_project(
f'{NEPTUNE_USER}/{NEPTUNE_PROJECT}')
exp = project.create_experiment(name=name, params=C)
_NEPTUNE['default'] = exp
logger.info("Initialized neptune")
def initialize(self):
# Get experiment
if self.offline:
project = neptune.Session(backend=neptune.OfflineBackend()
).get_project('dry-run/project')
else:
session = neptune.Session.with_default_backend(
api_token=self.api_key)
project = session.get_project(self.project_name)
exp = project.create_experiment(
name=self.experiment_name,
description=self.description,
params=self.hparams,
tags=self.tags,
upload_source_files=self.upload_source_files,
hostname=self.hostname)
self.experiment = exp
import neptune
from config import EnvConfig
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import pickle
%matplotlib qt
plt.rcParams.update({'font.size': 22})
comet_cfg = EnvConfig()
session = neptune.Session(api_token=comet_cfg.neptune_token)
project = session.get_project(project_qualified_name=comet_cfg.neptune_project_name)
experiments = project.get_experiments("GRID-30")
exp = experiments[0]
vals = exp.get_numeric_channels_values('insurance_cost_1_log_0','step_num_insured_1_log_0')
vals = vals.iloc[36210:36500,:]
vals[['insurance_cost_1_log_0','step_num_insured_1_log_0']].plot()
plt.legend(['Insurance price','Insurance usage'])
plt.xlabel('Timestep t')
experiments = project.get_experiments("GRID-81")
exp = experiments[0]
vals = exp.get_numeric_channels_values('insurance_cost_2_log_0','step_num_insured_2_log_0')
self.exp.send_metric('epoch end val loss', logs['val_loss'])
msg_acc = 'End of epoch {}, accuracy is {:.4f}'.format(epoch, logs['accuracy'])
self.exp.send_text(channel_name='accuracy information', x=epoch, y=msg_acc)
msg_loss = 'End of epoch {}, categorical crossentropy loss is {:.4f}'.format(epoch, logs['loss'])
self.exp.send_text(channel_name='loss information', x=epoch, y=msg_loss)
self.current_epoch += 1
neptune.init(api_token=PARAMS['api_token'],
project_qualified_name='kunalcgi/sandbox')
# retrieve project
project = neptune.Session(PARAMS['api_token'])\
.get_project('kunalcgi/sandbox')
# CallBAck
with project.create_experiment(name='repair-replace-classification-exp-v2',
params=PARAMS,
description=PARAMS['description'],
upload_source_files=[]) as npt_exp:
np_callback = NeptuneMonitor(npt_exp,999999999999)
model_checkpointer = ModelCheckpoint(PARAMS['model_path'], \
verbose=1, monitor='val_accuracy', mode='max', save_best_only=True, save_weights_only=False)
weight_checkpointer = ModelCheckpoint(PARAMS['weight_path'], \
verbose=1, monitor='val_accuracy', mode='max', save_best_only=True, save_weights_only=True)
learning_rate_reduction = ReduceLROnPlateau(monitor='val_loss',patience=5,verbose=1,factor=0.2,min_lr=0.0000032, cooldown=20)
earlystopper = EarlyStopping(monitor='val_mean_absolute_error', patience=20, verbose=1, mode='min')
callbacks_list = [CSVLogger(PARAMS['log_file']), model_checkpointer, weight_checkpointer, np_callback, learning_rate_reduction, earlystopper]
