code stringlengths 189 49.4k | apis list | extract_api stringlengths 107 64.3k |
|---|---|---|
import fastai
from neptune.new.integrations.fastai import NeptuneCallback
from fastai.vision.all import *
import neptune.new as neptune
run = neptune.init(
project="common/fastai-integration", api_token="<PASSWORD>", tags="basic"
)
path = untar_data(URLs.MNIST_TINY)
dls = ImageDataLoaders.from_csv(path)
# Log al... | [
"neptune.new.integrations.fastai.NeptuneCallback",
"neptune.new.init"
] | [((143, 234), 'neptune.new.init', 'neptune.init', ([], {'project': '"""common/fastai-integration"""', 'api_token': '"""<PASSWORD>"""', 'tags': '"""basic"""'}), "(project='common/fastai-integration', api_token='<PASSWORD>',\n tags='basic')\n", (155, 234), True, 'import neptune.new as neptune\n'), ((393, 446), 'neptun... |
import neptune
from tensorflow.keras.callbacks import BaseLogger
class NeptuneMonitor(BaseLogger):
def __init__(self, name, api_token, prj_name, params: tuple = None):
assert api_token is not None
assert prj_name is not None
super(BaseLogger, self).__init__()
self.my_name = name
... | [
"neptune.create_experiment",
"neptune.init"
] | [((379, 445), 'neptune.init', 'neptune.init', ([], {'api_token': 'api_token', 'project_qualified_name': 'prj_name'}), '(api_token=api_token, project_qualified_name=prj_name)\n', (391, 445), False, 'import neptune\n'), ((497, 556), 'neptune.create_experiment', 'neptune.create_experiment', ([], {'name': 'self.my_name', '... |
'''Train DCENet with PyTorch'''
# from __future__ import print_function
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
import os
import json
import neptune
import argparse
import numpy as np
from loader import *
from utils.plots import *
from utils.utils impor... | [
"neptune.init",
"neptune.log_metric",
"neptune.create_experiment",
"neptune.append_tag"
] | [((7920, 7935), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (7933, 7935), False, 'import torch\n'), ((564, 633), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""PyTorch Knowledge Distillation"""'}), "(description='PyTorch Knowledge Distillation')\n", (587, 633), False, 'import arg... |
import gym, torch, random, copy
import torch.nn as nn
import torch.optim as optim
import numpy as np
import torch.nn.functional as F
import neptune.new as neptune
# initialize policy & value network
class PolicyNetwork(nn.Module):
def __init__(self, beta):
super().__init__()
self.model = nn.Sequen... | [
"neptune.new.init"
] | [((1496, 1539), 'random.sample', 'random.sample', (['self.buffer', 'self.batch_size'], {}), '(self.buffer, self.batch_size)\n', (1509, 1539), False, 'import gym, torch, random, copy\n'), ((2259, 2271), 'torch.nn.MSELoss', 'nn.MSELoss', ([], {}), '()\n', (2269, 2271), True, 'import torch.nn as nn\n'), ((2277, 2295), 'gy... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.exceptions.ProjectNotFound",
"neptune.new.sync.get_project",
"neptune.new.sync.sync_all_runs",
"neptune.new.internal.utils.sync_offset_file.SyncOffsetFile",
"neptune.new.sync.get_qualified_name",
"neptune.new.sync.sync_selected_runs",
"neptune.new.sync.synchronization_status"
] | [((5024, 5056), 'neptune.new.sync.synchronization_status', 'synchronization_status', (['tmp_path'], {}), '(tmp_path)\n', (5046, 5056), False, 'from neptune.new.sync import ApiRun, get_project, get_qualified_name, sync_all_runs, sync_selected_runs, synchronization_status\n'), ((5802, 5834), 'neptune.new.sync.synchroniza... |
import neptune
# The init() function called this way assumes that
# NEPTUNE_API_TOKEN environment variable is defined.
neptune.init('zackpashkin/sandbox')
PARAMS = {'decay_factor' : 0.5,
'n_iterations' : 117}
neptune.create_experiment(name='minimal_example',params=PARAMS)
# log some metrics
for i in ran... | [
"neptune.create_experiment",
"neptune.init",
"neptune.log_metric"
] | [((121, 156), 'neptune.init', 'neptune.init', (['"""zackpashkin/sandbox"""'], {}), "('zackpashkin/sandbox')\n", (133, 156), False, 'import neptune\n'), ((223, 287), 'neptune.create_experiment', 'neptune.create_experiment', ([], {'name': '"""minimal_example"""', 'params': 'PARAMS'}), "(name='minimal_example', params=PAR... |
import requests
import pytest
from neptune.neptune_api import NeptuneService
from neptune.tests.conftest import get_server_addr
@pytest.mark.fpgas(1)
def test_coco(request):
"""
Check the coco service from Neptune with a known image
Args:
request (fixture): get the cmdline options
"""
ser... | [
"neptune.neptune_api.NeptuneService",
"neptune.tests.conftest.get_server_addr"
] | [((131, 151), 'pytest.mark.fpgas', 'pytest.mark.fpgas', (['(1)'], {}), '(1)\n', (148, 151), False, 'import pytest\n'), ((331, 362), 'neptune.tests.conftest.get_server_addr', 'get_server_addr', (['request.config'], {}), '(request.config)\n', (346, 362), False, 'from neptune.tests.conftest import get_server_addr\n'), ((4... |
"""
Script by <NAME>, November 2020
Used to finetune models trained on pathology images (pre-chunked) on External Images
"""
import numpy as np
import tables
import pickle
import neptune
from neptunecontrib.monitoring.keras import NeptuneMonitor
import collections
from sklearn.utils import class_weight
import cv2
fr... | [
"neptune.init"
] | [((1446, 1542), 'neptune.init', 'neptune.init', ([], {'api_token': 'neptune_api_key', 'project_qualified_name': '"""yashaektefaie/benignmodel"""'}), "(api_token=neptune_api_key, project_qualified_name=\n 'yashaektefaie/benignmodel')\n", (1458, 1542), False, 'import neptune\n'), ((2046, 2083), 'tables.open_file', 'ta... |
import warnings
from typing import Callable, Sequence, Union
import joblib
import neptune.new as neptune
import neptune.new.integrations.optuna as optuna_utils
import optuna
import pandas as pd
from optuna.samplers import TPESampler
from optuna.study import Study
from optuna.trial import FrozenTrial, Trial
from sklear... | [
"neptune.new.init",
"neptune.new.integrations.optuna.NeptuneCallback"
] | [((391, 424), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (414, 424), False, 'import warnings\n'), ((3692, 3713), 'xgboost.XGBRegressor', 'XGBRegressor', ([], {}), '(**param)\n', (3704, 3713), False, 'from xgboost import XGBRegressor\n'), ((3936, 3971), 'sklearn.metrics... |
import neptune
def _update_keys(d, prefix):
keys = list(d.keys())
for k in keys:
d['{}_{}'.format(prefix, k)] = d.pop(k)
class NeptuneWriter:
def __init__(self, proj_name):
self.project = neptune.init(proj_name)
self.has_started = False
def start(self, args, **kwargs):
... | [
"neptune.init"
] | [((220, 243), 'neptune.init', 'neptune.init', (['proj_name'], {}), '(proj_name)\n', (232, 243), False, 'import neptune\n')] |
import neptune.new as neptune
import os
import torch.nn as nn
import torch
import torch.nn.functional as F
from torch.optim import SGD, Adam
from torch.utils.data import DataLoader, random_split
from torch.optim.lr_scheduler import CyclicLR
import torch.multiprocessing as mp
import numpy as np
import random
import math... | [
"neptune.new.init"
] | [((333, 354), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (348, 354), False, 'import sys\n'), ((703, 731), 'torch.multiprocessing.set_start_method', 'mp.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (722, 731), True, 'import torch.multiprocessing as mp\n'), ((828, 852), 'os.getenv',... |
# -*- coding: utf-8 -*-
#
# Copyright (c) 2017, deepsense.io
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicab... | [
"neptune.internal.cli.storage.upload_storage_utils.upload_to_storage",
"neptune.internal.cli.commands.enqueue_utils.EnqueueUtils",
"neptune.internal.common.config.neptune_config.load_global_config",
"neptune.internal.cli.storage.populate_storage_utils.CopyProgressBar",
"neptune.internal.common.NeptuneExcept... | [((2775, 2821), 'neptune.internal.cli.commands.enqueue_utils.EnqueueUtils', 'EnqueueUtils', (['config', 'api_service', 'web_browser'], {}), '(config, api_service, web_browser)\n', (2787, 2821), False, 'from neptune.internal.cli.commands.enqueue_utils import EnqueueUtils\n'), ((2957, 2983), 'neptune.internal.cli.command... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.exceptions.MetadataInconsistency",
"neptune.new.internal.utils.paths.join_paths",
"neptune.new.internal.utils.paths.parse_path"
] | [((8356, 8405), 'pandas.DataFrame.from_dict', 'pd.DataFrame.from_dict', ([], {'data': 'rows', 'orient': '"""index"""'}), "(data=rows, orient='index')\n", (8378, 8405), True, 'import pandas as pd\n'), ((5444, 5472), 'neptune.new.internal.utils.paths.join_paths', 'join_paths', (['self._path', 'path'], {}), '(self._path, ... |
"""Implements Neptune Logger."""
from abc import ABC
from typing import TYPE_CHECKING, List
from torchflare.callbacks.callback import Callbacks
from torchflare.callbacks.states import CallbackOrder
from torchflare.utils.imports_check import module_available
_AVAILABLE = module_available("neptune")
if _AVAILABLE:
... | [
"neptune.new.init"
] | [((273, 300), 'torchflare.utils.imports_check.module_available', 'module_available', (['"""neptune"""'], {}), "('neptune')\n", (289, 300), False, 'from torchflare.utils.imports_check import module_available\n'), ((2068, 2180), 'neptune.new.init', 'neptune.init', ([], {'project': 'self.project_dir', 'api_token': 'self.a... |
#!/usr/bin/env python
# The MIT License (MIT)
# Copyright (c) 2020 <NAME>
# Paper: "Self-Supervised Relational Reasoning for Representation Learning", <NAME> & <NAME>, NeurIPS 2020
# GitHub: https://github.com/mpatacchiola/self-supervised-relational-reasoning
#
# Implementation of a standard neural network (no self-su... | [
"neptune.send_metric",
"neptune.create_experiment",
"neptune.init"
] | [((1075, 1111), 'torch.nn.Linear', 'nn.Linear', (['feature_size', 'num_classes'], {}), '(feature_size, num_classes)\n', (1084, 1111), False, 'from torch import nn\n'), ((1130, 1157), 'torch.nn.CrossEntropyLoss', 'torch.nn.CrossEntropyLoss', ([], {}), '()\n', (1155, 1157), False, 'import torch\n'), ((1713, 1757), 'neptu... |
# -*- coding: utf-8 -*-
#
# Copyright (c) 2017, deepsense.io
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicab... | [
"neptune.internal.common.api.api_service_factory.create_services",
"neptune.internal.common.threads.neptune_future.NeptuneFuture",
"neptune.internal.common.NeptuneInternalException",
"neptune.internal.common.NeptuneException"
] | [((2326, 2358), 'future.builtins.input', 'input', (['u"""Authentication token: """'], {}), "(u'Authentication token: ')\n", (2331, 2358), False, 'from future.builtins import input\n'), ((2672, 2707), 'neptune.internal.common.api.api_service_factory.create_services', 'create_services', (['self.token_storage'], {}), '(se... |
import neptune
# The init() function called this way assumes that
# NEPTUNE_API_TOKEN environment variable is defined.
neptune.init('vanducng/sandbox')
neptune.create_experiment(name='minimal_example')
# log some metrics
for i in range(100):
neptune.log_metric('loss', 0.95**i)
neptune.log_metric('AUC', 0.96) | [
"neptune.create_experiment",
"neptune.init",
"neptune.log_metric"
] | [((121, 153), 'neptune.init', 'neptune.init', (['"""vanducng/sandbox"""'], {}), "('vanducng/sandbox')\n", (133, 153), False, 'import neptune\n'), ((154, 203), 'neptune.create_experiment', 'neptune.create_experiment', ([], {'name': '"""minimal_example"""'}), "(name='minimal_example')\n", (179, 203), False, 'import neptu... |
import sys
from dataclasses import asdict
from pathlib import Path
from pprint import pprint
from typing import Optional
import click
import matplotlib.pyplot as plt
import neptune
import torch
import torchaudio
from click import Context
from torch.nn.functional import mse_loss
from tqdm import trange, tqdm
from refo... | [
"neptune.init"
] | [((925, 938), 'click.group', 'click.group', ([], {}), '()\n', (936, 938), False, 'import click\n'), ((940, 1014), 'click.option', 'click.option', (['"""-c"""', '"""--config"""'], {'envvar': '"""REFORMER_TTS_CONFIG"""', 'default': 'None'}), "('-c', '--config', envvar='REFORMER_TTS_CONFIG', default=None)\n", (952, 1014),... |
import itertools
import json
import logging
import os
import tempfile
from typing import List, Any, Dict, Tuple
import gin
import numpy as np
import pandas as pd
from experiments.src.gin import get_default_experiment_name, parse_gin_str
from experiments.src.training.training_utils import get_metric_cls
GridResultDic... | [
"neptune.init"
] | [((486, 515), 'experiments.src.gin.get_default_experiment_name', 'get_default_experiment_name', ([], {}), '()\n', (513, 515), False, 'from experiments.src.gin import get_default_experiment_name, parse_gin_str\n'), ((523, 563), 'gin.query_parameter', 'gin.query_parameter', (['"""train.use_neptune"""'], {}), "('train.use... |
#
# Copyright (c) 2022, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.exceptions.ProjectNotFound",
"neptune.new.sync.utils.get_project"
] | [((760, 790), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""backend"""'}), "(name='backend')\n", (774, 790), False, 'import pytest\n'), ((825, 836), 'unittest.mock.MagicMock', 'MagicMock', ([], {}), '()\n', (834, 836), False, 'from unittest.mock import MagicMock\n'), ((1143, 1165), 'neptune.new.exceptions.Proje... |
import logging
import os as os
import tempfile
import datetime as dt
from matplotlib import pyplot as plt
import neptune as npt
from neptunecontrib import api as npta
from neptunecontrib import hpo as npth
from neptunecontrib.monitoring import optuna as nmo
from neptunecontrib.monitoring import keras as nmk
class E... | [
"neptune.create_experiment",
"neptune.set_project"
] | [((745, 797), 'neptune.set_project', 'npt.set_project', ([], {'project_qualified_name': 'project_name'}), '(project_qualified_name=project_name)\n', (760, 797), True, 'import neptune as npt\n'), ((846, 915), 'neptune.create_experiment', 'npt.create_experiment', ([], {'name': 'experiment_name', 'params': 'experiment_par... |
import random
import neptune
import numpy as np
import tensorflow as tf
import neptune_tensorboard as neptune_tb
from absl import flags
from absl import app
from data_processor import read_data
from tensorflow.keras import callbacks, Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalizati... | [
"neptune.create_experiment",
"neptune.init"
] | [((369, 463), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""mode"""', '"""train"""', '"""In which mode should the program be run train/eval"""'], {}), "('mode', 'train',\n 'In which mode should the program be run train/eval')\n", (388, 463), False, 'from absl import flags\n'), ((460, 509), 'absl.flags.DEF... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.utils.is_float_like",
"neptune.new.types.atoms.float.Float",
"neptune.new.internal.utils.is_string_like",
"neptune.new.internal.utils.is_int",
"neptune.new.attributes.atoms.file.File",
"neptune.new.attributes.atoms.datetime.Datetime",
"neptune.new.types.Boolean",
"neptune.new.int... | [((3256, 3273), 'threading.RLock', 'threading.RLock', ([], {}), '()\n', (3271, 3273), False, 'import threading\n'), ((3393, 3445), 'traceback.print_exception', 'traceback.print_exception', (['exc_type', 'exc_val', 'exc_tb'], {}), '(exc_type, exc_val, exc_tb)\n', (3418, 3445), False, 'import traceback\n'), ((3533, 3552)... |
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
comet_cfg = EnvConfig()
session = neptune.Session(api_token=comet_cfg.neptune_token)
project = session.get_project(project_qualified_name=comet_cfg.ne... | [
"neptune.Session"
] | [((182, 193), 'config.EnvConfig', 'EnvConfig', ([], {}), '()\n', (191, 193), False, 'from config import EnvConfig\n'), ((204, 254), 'neptune.Session', 'neptune.Session', ([], {'api_token': 'comet_cfg.neptune_token'}), '(api_token=comet_cfg.neptune_token)\n', (219, 254), False, 'import neptune\n'), ((1362, 1394), 'pickl... |
# importing neptune
import neptune
# File data version
from neptunecontrib.versioning.data import log_data_version
# File Loader
from data_loader import data_loader
# Hyperparameter Tuner
from hyperparameter_optimizer import create_objective
# Model
from model.lightgbm_0.model import learning
# set UserName/Experiment... | [
"neptune.create_experiment",
"neptune.init"
] | [((325, 357), 'neptune.init', 'neptune.init', (['"""toroi/HousePrice"""'], {}), "('toroi/HousePrice')\n", (337, 357), False, 'import neptune\n'), ((623, 663), 'data_loader.data_loader', 'data_loader', (['TRAIN_FILEPATH', 'TARGET_LIST'], {}), '(TRAIN_FILEPATH, TARGET_LIST)\n', (634, 663), False, 'from data_loader import... |
from functools import partial
import os
from datetime import datetime, timedelta
import numpy as np
import torch
from PIL import Image
import neptune
from torch.autograd import Variable
from torch.optim.lr_scheduler import ExponentialLR
from tempfile import TemporaryDirectory
from steppy.base import Step, IdentityOpe... | [
"neptune.Context"
] | [((6126, 6182), 'torch.optim.lr_scheduler.ExponentialLR', 'ExponentialLR', (['self.optimizer', 'self.gamma'], {'last_epoch': '(-1)'}), '(self.optimizer, self.gamma, last_epoch=-1)\n', (6139, 6182), False, 'from torch.optim.lr_scheduler import ExponentialLR\n'), ((8226, 8240), 'datetime.datetime.now', 'datetime.now', ([... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.init_project",
"neptune.management.create_project",
"neptune.management.add_project_member",
"neptune.management.internal.utils.normalize_project_name",
"neptune.new.init_run"
] | [((889, 896), 'faker.Faker', 'Faker', ([], {}), '()\n', (894, 896), False, 'from faker import Faker\n'), ((900, 931), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (914, 931), False, 'import pytest\n'), ((1878, 1909), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""... |
import neptune.new as neptune
import os
from GTApack.GTA_hotloader import GTA_hotloader
from GTApack.GTA_Unet import GTA_Unet
from GTApack.GTA_tester import GTA_tester
from torchvision import datasets, transforms
from torch.optim import SGD, Adam
from torch.optim.lr_scheduler import (ReduceLROnPlateau, CyclicLR,
... | [
"neptune.new.init",
"neptune.new.types.File"
] | [((701, 719), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (715, 719), True, 'import numpy as np\n'), ((983, 1027), 'numpy.random.randint', 'np.random.randint', ([], {'low': '(1)', 'high': '(856)', 'size': '(200)'}), '(low=1, high=856, size=200)\n', (1000, 1027), True, 'import numpy as np\n'), ((104... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.internal.utils.verify_type",
"neptune.internal.utils.compatibility.expect_not_an_experiment",
"neptune.types.FileSeries",
"neptune.types.File.as_pickle",
"neptune.types.File.as_image"
] | [((6737, 6766), 'neptune.internal.utils.compatibility.expect_not_an_experiment', 'expect_not_an_experiment', (['run'], {}), '(run)\n', (6761, 6766), False, 'from neptune.internal.utils.compatibility import expect_not_an_experiment\n'), ((6775, 6811), 'neptune.internal.utils.verify_type', 'verify_type', (['"""run"""', '... |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
#hide
get_ipython().run_line_magic('load_ext', 'autoreload')
get_ipython().run_line_magic('autoreload', '2')
# In[2]:
# default_exp core
# In[3]:
#export
from nbdev.export import check_re,read_nb
from pathlib import Path
import re
import os
import platform
# #... | [
"neptune.sessions.Session"
] | [((412, 817), 're.compile', 're.compile', (['"""\n# Matches any line with #export or #exports without any module name:\n^ # beginning of line (since re.MULTILINE is passed)\n\\\\s* # any number of whitespace\n\\\\#\\\\s* # # then any number of whitespace\ncode # export or exports\n\\\\s* # any ... |
from typing import Dict
import neptune.new as neptune
import numpy as np
import pytorch_lightning as pl
import torch
import torch.nn as nn
from config import NEPTUNE_API_TOKEN, NEPTUNE_PROJECT_NAME
from sklearn.metrics import classification_report, f1_score
from utils.summary_loss import SummaryLoss
from math import c... | [
"neptune.new.init"
] | [((790, 920), 'neptune.new.init', 'neptune.init', ([], {'api_token': 'NEPTUNE_API_TOKEN', 'project': 'NEPTUNE_PROJECT_NAME', 'tags': 'tags', 'capture_stdout': '(False)', 'capture_stderr': '(False)'}), '(api_token=NEPTUNE_API_TOKEN, project=NEPTUNE_PROJECT_NAME,\n tags=tags, capture_stdout=False, capture_stderr=False... |
import argparse
import shutil
import sys
import time
import torch.nn.parallel
import torch.optim
import torch.utils.data
from plot_functions_cw import *
from helper_functions import *
from PIL import ImageFile
import neptune.new as neptune
from access_keys import neptune_key
run = neptune.init(project='irmavdbrandt/In... | [
"neptune.new.init"
] | [((283, 396), 'neptune.new.init', 'neptune.init', ([], {'project': '"""irmavdbrandt/Interpret-rna"""', 'api_token': 'neptune_key', 'source_files': "['train_premirna.py']"}), "(project='irmavdbrandt/Interpret-rna', api_token=neptune_key,\n source_files=['train_premirna.py'])\n", (295, 396), True, 'import neptune.new ... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.artifacts.types.ArtifactDriversMap.match_path",
"neptune.new.internal.artifacts.drivers.local.LocalArtifactDriver.download_file",
"neptune.new.internal.artifacts.types.ArtifactFileData",
"neptune.new.internal.artifacts.drivers.local.LocalArtifactDriver.get_tracked_files",
"neptune.new.... | [((1537, 1593), 'shutil.copytree', 'shutil.copytree', (['test_source_data', 'self.test_sources_dir'], {}), '(test_source_data, self.test_sources_dir)\n', (1552, 1593), False, 'import shutil\n'), ((1635, 1703), 'shutil.copytree', 'shutil.copytree', (["(self.test_sources_dir / 'files_to_track')", 'test_data'], {}), "(sel... |
import images as images
import numpy as np
import pandas as pd
import xgboost as xgb
from sklearn.metrics import r2_score
from sklearn.metrics import mean_squared_error as mse
from sklearn.model_selection import train_test_split
from sklearn.multioutput import MultiOutputRegressor
import pickle
import neptune
import os... | [
"neptune.stop",
"neptune.create_experiment",
"neptune.log_artifact"
] | [((330, 360), 'os.getenv', 'os.getenv', (['"""NEPTUNE_API_TOKEN"""'], {}), "('NEPTUNE_API_TOKEN')\n", (339, 360), False, 'import os\n'), ((680, 703), 'images.get_data_files', 'images.get_data_files', ([], {}), '()\n', (701, 703), True, 'import images as images\n'), ((1235, 1285), 'pandas.DataFrame', 'pd.DataFrame', ([]... |
import json
import pandas as pd
import lightgbm as lgb
from loguru import logger
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
import neptune
from neptunecontrib.monitoring.lightgbm import neptune_monitor
from src.utils.read_params import read_params
if __name__ == '__main... | [
"neptune.stop",
"neptune.init"
] | [((329, 394), 'loguru.logger.add', 'logger.add', (['"""logs/logs_lgbm.txt"""'], {'level': '"""TRACE"""', 'rotation': '"""10 KB"""'}), "('logs/logs_lgbm.txt', level='TRACE', rotation='10 KB')\n", (339, 394), False, 'from loguru import logger\n'), ((404, 418), 'loguru.logger.catch', 'logger.catch', ([], {}), '()\n', (416... |
# -*- coding: utf-8 -*-
import argparse
import sys
import time
from datetime import datetime
import neptune
import torch
import numpy as np
from torch.utils.data import SequentialSampler, RandomSampler
import pandas as pd
sys.path.insert(0, '.')
from configs import CONFIGS # noqa
from src.dataset import DatasetRetr... | [
"neptune.init"
] | [((224, 247), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""."""'], {}), "(0, '.')\n", (239, 247), False, 'import sys\n'), ((654, 710), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Run train script."""'}), "(description='Run train script.')\n", (677, 710), False, 'import argparse\... |
# -*- coding: utf-8 -*-
#
# Copyright (c) 2016, deepsense.io
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicab... | [
"neptune.internal.common.local_storage.local_storage.LocalStorage.profile",
"neptune.internal.common.utils.neptune_warnings.neptune_warn",
"neptune.internal.cli.commands.utils.urls.Urls",
"neptune.internal.common.api.job_api_service.JobApiService",
"neptune.internal.client_library.offline.OfflineIntegration... | [((18982, 19058), 'neptune.internal.common.api.neptune_api.handler.create_base_neptune_api_handler', 'create_base_neptune_api_handler', (['rest_api_url', 'offline_token_storage_service'], {}), '(rest_api_url, offline_token_storage_service)\n', (19013, 19058), False, 'from neptune.internal.common.api.neptune_api.handler... |
import argparse
import os
import os.path as osp
import torch.nn.functional as F
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import network
import loss
from torch.utils.data import DataLoader
import lr_schedule
import data_list
from data_list import ImageList, split_train_test
from... | [
"neptune.log_metric",
"neptune.create_experiment",
"neptune.init",
"neptune.append_tag"
] | [((482, 494), 'torch.nn.functional.softmax', 'F.softmax', (['p'], {}), '(p)\n', (491, 494), True, 'import torch.nn.functional as F\n'), ((2847, 2871), 'torch.max', 'torch.max', (['all_output', '(1)'], {}), '(all_output, 1)\n', (2856, 2871), False, 'import torch\n'), ((3848, 3892), 'pre_process.image_train', 'prep.image... |
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from collections import defaultdict
from neptune import Session
import numpy as np
import pandas as pd
session = Session()
project = session.get_projects('csadrian')['csadrian/global-sinkhorn']
def check_crit(params, crit):
for k, v in crit.it... | [
"neptune.Session"
] | [((18, 39), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (32, 39), False, 'import matplotlib\n'), ((187, 196), 'neptune.Session', 'Session', ([], {}), '()\n', (194, 196), False, 'from neptune import Session\n'), ((3150, 3166), 'numpy.stack', 'np.stack', (['tables'], {}), '(tables)\n', (3158, 31... |
from functools import partial
import hydra
import neptune.new as neptune
from omegaconf import DictConfig
from data.dataset import load_train_dataset
from tuning.bayesian import BayesianSearch, xgb_objective
@hydra.main(config_path="../config/tuning/", config_name="xgb.yaml")
def _main(cfg: DictConfig):
print("... | [
"neptune.new.init"
] | [((213, 280), 'hydra.main', 'hydra.main', ([], {'config_path': '"""../config/tuning/"""', 'config_name': '"""xgb.yaml"""'}), "(config_path='../config/tuning/', config_name='xgb.yaml')\n", (223, 280), False, 'import hydra\n'), ((353, 376), 'data.dataset.load_train_dataset', 'load_train_dataset', (['cfg'], {}), '(cfg)\n'... |
import neptune.new as neptune
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
TRAIN_DATASET_PATH = '../datasets/tables/train.csv'
TEST_DATASET_PATH = '../datasets/tables/test.csv'
PARAMS = {'n_estimators': 7,
'max_depth': 2,
'max_features': 2,
}
def train_model(... | [
"neptune.new.init"
] | [((956, 1026), 'neptune.new.init', 'neptune.init', ([], {'project': '"""common/data-versioning"""', 'api_token': '"""<PASSWORD>"""'}), "(project='common/data-versioning', api_token='<PASSWORD>')\n", (968, 1026), True, 'import neptune.new as neptune\n'), ((1630, 1699), 'neptune.new.init', 'neptune.init', ([], {'project'... |
#!/usr/bin/env python
# coding: utf-8
"""investigate the effect of data augmentation with Adam optimizer without lr scheduler on model performance"""
# NOTE: 000_004 is not improving score much.
# TODO: perform the Learning Rate Range test and plot the result
# TODO: add model parameters to Neptune
# NOTE: Params: eff... | [
"neptune.log_metric",
"neptune.create_experiment",
"neptune.init",
"neptune.append_tag"
] | [((1165, 1198), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (1188, 1198), False, 'import warnings\n'), ((5943, 5974), 'os.path.join', 'os.path.join', (['data_dir', '"""train"""'], {}), "(data_dir, 'train')\n", (5955, 5974), False, 'import os\n'), ((5990, 6020), 'os.path... |
#
# Copyright (c) 2019, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.init"
] | [((819, 840), 'os.path.abspath', 'os.path.abspath', (['path'], {}), '(path)\n', (834, 840), False, 'import os\n'), ((855, 904), 'neptune.init', 'neptune.init', ([], {'project_qualified_name': 'project_name'}), '(project_qualified_name=project_name)\n', (867, 904), False, 'import neptune\n'), ((4790, 4801), 'sys.exit', ... |
from keras.backend import clear_session
from keras.layers import Conv1D
from keras.layers import Dense
from keras.layers import Flatten
import optuna
import neptune
import numpy as np
import tensorflow as tf
import neptunecontrib.monitoring.optuna as opt_utils
from tensorflow.keras.layers import Input, Con... | [
"neptune.create_experiment",
"neptune.init",
"neptune.stop"
] | [((685, 781), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""data_dir"""', '"""../data/uniform_200k/"""', '"""Relative path to the data folder"""'], {}), "('data_dir', '../data/uniform_200k/',\n 'Relative path to the data folder')\n", (704, 781), False, 'from absl import flags, app\n'), ((899, 935), 'data_... |
# coding=utf-8
# Copyright 2018 <NAME>.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to i... | [
"neptune.init",
"neptune.utils.get_git_info"
] | [((937, 1102), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""config_file"""', 'None', '"""Path to file that contains JSON serialized model configuration. If thisis specified, ignores \'config\' parameter."""'], {}), '(\'config_file\', None,\n "Path to file that contains JSON serialized model configuration... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.attributes.atoms.datetime.DatetimeVal",
"neptune.new.attributes.atoms.datetime.Datetime",
"neptune.new.internal.operation.AssignDatetime"
] | [((984, 998), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (996, 998), False, 'from datetime import datetime\n'), ((1880, 1899), 'neptune.new.attributes.atoms.datetime.Datetime', 'Datetime', (['exp', 'path'], {}), '(exp, path)\n', (1888, 1899), False, 'from neptune.new.attributes.atoms.datetime import Dat... |
import random
import neptune
import numpy as np
import tensorflow as tf
import neptune_tensorboard as neptune_tb
from absl import flags
from absl import app
from data_processor import read_data
from tensorflow.keras import callbacks, Sequential
from tensorflow.keras.layers import SimpleRNN, Dense, Dropout, BatchNormal... | [
"neptune.create_experiment",
"neptune.init"
] | [((374, 468), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""mode"""', '"""train"""', '"""In which mode should the program be run train/eval"""'], {}), "('mode', 'train',\n 'In which mode should the program be run train/eval')\n", (393, 468), False, 'from absl import flags\n'), ((465, 514), 'absl.flags.DEF... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.operation.AssignString",
"neptune.new.internal.operation.ClearFloatLog",
"neptune.new.internal.operation.ClearImageLog",
"neptune.new.internal.operation.ConfigFloatSeries",
"neptune.new.internal.operation.ClearStringSet",
"neptune.new.internal.operation.RemoveStrings",
"neptune.new... | [((1392, 1416), 'neptune.new.internal.backends.operations_preprocessor.OperationsPreprocessor', 'OperationsPreprocessor', ([], {}), '()\n', (1414, 1416), False, 'from neptune.new.internal.backends.operations_preprocessor import OperationsPreprocessor\n'), ((2645, 2669), 'neptune.new.internal.backends.operations_preproc... |
import gym
import neptune
import tensorflow as tf
from spinup import ppo_tf1 as ppo
def env_fn(): return gym.make('LunarLander-v2')
ac_kwargs = dict(hidden_sizes=[64, 64], activation=tf.nn.relu)
neptune.init(project_qualified_name='<namespace/project_name>')
experiment = neptune.create_experiment(name='Spinning U... | [
"neptune.create_experiment",
"neptune.init"
] | [((201, 264), 'neptune.init', 'neptune.init', ([], {'project_qualified_name': '"""<namespace/project_name>"""'}), "(project_qualified_name='<namespace/project_name>')\n", (213, 264), False, 'import neptune\n'), ((278, 331), 'neptune.create_experiment', 'neptune.create_experiment', ([], {'name': '"""Spinning Up example"... |
# -*- coding: utf-8 -*-
# @Time : 5/27/2020 5:45 PM
# @Author : <NAME>
# @Email : <EMAIL>
# @File : logger.py
# from pathlib import Path
# import pandas as pd
# import yaml
from abc import ABCMeta, abstractmethod
# from collections import defaultdict
from typing import Any, Optional, Union, Sequence
import wan... | [
"neptune.new.init"
] | [((10878, 11142), 'wandb.init', 'wandb.init', (['job_type', 'dir', 'config', 'project', 'entity', 'reinit', 'tags', 'group', 'name', 'notes', 'magic', 'config_exclude_keys', 'config_include_keys', 'anonymous', 'mode', 'allow_val_change', 'resume', 'force', 'tensorboard', 'sync_tensorboard', 'monitor_gym', 'save_code', ... |
import lightgbm
import matplotlib.pyplot as plt
import neptune
from neptunecontrib.monitoring.utils import pickle_and_send_artifact
from neptunecontrib.monitoring.metrics import log_binary_classification_metrics
from neptunecontrib.versioning.data import log_data_version
import pandas as pd
plt.rcParams.update({'font.... | [
"neptune.create_experiment",
"neptune.stop",
"neptune.init"
] | [((293, 331), 'matplotlib.pyplot.rcParams.update', 'plt.rcParams.update', (["{'font.size': 18}"], {}), "({'font.size': 18})\n", (312, 331), True, 'import matplotlib.pyplot as plt\n'), ((332, 381), 'matplotlib.pyplot.rcParams.update', 'plt.rcParams.update', (["{'figure.figsize': [16, 12]}"], {}), "({'figure.figsize': [1... |
from functools import partial
import os
import shutil
from attrdict import AttrDict
import neptune
import numpy as np
import pandas as pd
from sklearn.externals import joblib
from steppy.base import Step, IdentityOperation
from steppy.adapter import Adapter, E
from common_blocks import augmentation as aug
from common... | [
"neptune.Context"
] | [((492, 509), 'neptune.Context', 'neptune.Context', ([], {}), '()\n', (507, 509), False, 'import neptune\n'), ((519, 538), 'common_blocks.utils.init_logger', 'utils.init_logger', ([], {}), '()\n', (536, 538), False, 'from common_blocks import utils\n'), ((1204, 1233), 'os.path.isdir', 'os.path.isdir', (['EXPERIMENT_DIR... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.utils.verify_type",
"neptune.new.internal.utils.base64_encode",
"neptune.new.types.atoms.file.File.create_from"
] | [((1013, 1049), 'neptune.new.internal.utils.verify_type', 'verify_type', (['"""value"""', 'value', 'FileVal'], {}), "('value', value, FileVal)\n", (1024, 1049), False, 'from neptune.new.internal.utils import verify_type, base64_encode\n'), ((1690, 1716), 'neptune.new.types.atoms.file.File.create_from', 'FileVal.create_... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.management.create_project",
"neptune.management.add_project_member",
"neptune.management.internal.utils.normalize_project_name"
] | [((931, 938), 'faker.Faker', 'Faker', ([], {}), '()\n', (936, 938), False, 'from faker import Faker\n'), ((942, 973), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (956, 973), False, 'import pytest\n'), ((1940, 1971), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""... |
from __future__ import print_function
import yaml
import easydict
import os
import argparse
import numpy as np
import torch
from torch import nn
from torch.autograd import Variable
from apex import amp, optimizers
from data_loader.get_loader import get_dataloaders
from utils.utils import get_models, get_optimizers, lo... | [
"neptune.log_metric",
"neptune.create_experiment",
"neptune.init",
"neptune.append_tag"
] | [((660, 684), 'data_loader.get_loader.get_dataloaders', 'get_dataloaders', (['configs'], {}), '(configs)\n', (675, 684), False, 'from data_loader.get_loader import get_dataloaders\n'), ((708, 724), 'utils.utils.log_set', 'log_set', (['configs'], {}), '(configs)\n', (715, 724), False, 'from utils.utils import get_models... |
from collections import OrderedDict
from hyperopt import hp, tpe, fmin, Trials
import neptune
import neptunecontrib.hpo.utils as hpo_utils
import neptunecontrib.monitoring.skopt as sk_utils
import numpy as np
import pandas as pd
from sklearn.externals import joblib
from utils import train_evaluate, axes2fig
neptune.... | [
"neptune.send_metric",
"neptune.create_experiment",
"neptune.send_artifact",
"neptune.init"
] | [((312, 372), 'neptune.init', 'neptune.init', ([], {'project_qualified_name': '"""jakub-czakon/blog-hpo"""'}), "(project_qualified_name='jakub-czakon/blog-hpo')\n", (324, 372), False, 'import neptune\n'), ((1217, 1254), 'pandas.read_csv', 'pd.read_csv', (['TRAIN_PATH'], {'nrows': 'N_ROWS'}), '(TRAIN_PATH, nrows=N_ROWS)... |
import random
import json
import argparse
import os
import torch
from torch.utils.data import DataLoader
from torch.optim import Adam
from runner.gegl_trainer import GeneticExpertGuidedLearningTrainer
from runner.guacamol_generator import GeneticExpertGuidedLearningGenerator
from model.neural_apprentice import Smiles... | [
"neptune.set_property",
"neptune.append_tag",
"neptune.init"
] | [((681, 781), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '""""""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description='', formatter_class=argparse.\n ArgumentDefaultsHelpFormatter)\n", (704, 781), False, 'import argparse\n'), ((2098, 2113), 'torch.device', 't... |
import math
from typing import Any, Dict
from neptune import new as neptune
import pandas as pd
from kedro.pipeline import Pipeline, node
# ------ Looking for furthest planet -------
def distances(planets: pd.DataFrame) -> Any:
planets['Distance from Sun'] = planets['Distance from Sun (106 km)'].apply(lambda ro... | [
"neptune.new.init"
] | [((914, 1023), 'neptune.new.init', 'neptune.init', ([], {'capture_stdout': '(False)', 'capture_stderr': '(False)', 'capture_hardware_metrics': '(False)', 'source_files': '[]'}), '(capture_stdout=False, capture_stderr=False,\n capture_hardware_metrics=False, source_files=[])\n', (926, 1023), True, 'from neptune impor... |
import hashlib
import neptune
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from sklearn.metrics import accuracy_score
from torchvision import datasets, transforms
class Net(nn.Module):
def __init__(self, fc_out_features):
super(Net, self).__init__()
... | [
"neptune.log_metric",
"neptune.create_experiment",
"neptune.log_artifact",
"neptune.init"
] | [((971, 1015), 'neptune.init', 'neptune.init', (['"""neptune-ai/tour-with-pytorch"""'], {}), "('neptune-ai/tour-with-pytorch')\n", (983, 1015), False, 'import neptune\n'), ((1037, 1128), 'neptune.create_experiment', 'neptune.create_experiment', ([], {'name': '"""pytorch-run"""', 'tags': "['pytorch', 'MNIST']", 'params'... |
import argparse
import copy
import os
import neptune
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from hyperopt import Trials, fmin, hp, tpe
from purano.clusterer.clusterer import Clusterer
from purano.clusterer.metrics import calc_metrics
from purano.io import parse_tg_jsonl, parse_cl... | [
"neptune.log_metric",
"neptune.create_experiment",
"neptune.stop",
"neptune.init"
] | [((1179, 1216), 'os.path.isfile', 'os.path.isfile', (['clustering_markup_tsv'], {}), '(clustering_markup_tsv)\n', (1193, 1216), False, 'import os\n'), ((1278, 1308), 'os.path.isfile', 'os.path.isfile', (['original_jsonl'], {}), '(original_jsonl)\n', (1292, 1308), False, 'import os\n'), ((1365, 1387), 'os.path.isfile', ... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.backends.api_model.BoolAttribute",
"neptune.new.types.atoms.artifact.Artifact",
"neptune.new.exceptions.RunNotFound",
"neptune.new.internal.backends.api_model.StringAttribute",
"neptune.new.types.atoms.float.Float",
"neptune.new.internal.backends.api_model.Project",
"neptune.new.ty... | [((3621, 3648), 'typing.TypeVar', 'TypeVar', (['"""Val"""'], {'bound': 'Value'}), "('Val', bound=Value)\n", (3628, 3648), False, 'from typing import Any, Dict, Iterable, List, Optional, Tuple, Type, TypeVar, Union\n'), ((3783, 3799), 'neptune.new.internal.id_formats.SysId', 'SysId', (['"""OFFLINE"""'], {}), "('OFFLINE'... |
"""Neptune logger."""
import neptune
import numpy as np
from ray import tune
class NeptuneLogger(tune.logger.Logger):
"""RLlib Neptune logger.
Example usage:
```
import ray
from ray import tune
ray.init()
tune.run(
"PPO",
stop={"episode_reward_mean": 200},
confi... | [
"neptune.stop"
] | [((2525, 2539), 'neptune.stop', 'neptune.stop', ([], {}), '()\n', (2537, 2539), False, 'import neptune\n')] |
import neptune
neptune.init('shared/onboarding', api_token='<KEY>')
with neptune.create_experiment(name='hello-neptune'):
neptune.append_tag('introduction-minimal-example')
n = 117
for i in range(1, n):
neptune.log_metric('iteration', i)
neptune.log_metric('loss', 1/i**0.5)
neptune.log_text('magi... | [
"neptune.set_property",
"neptune.log_metric",
"neptune.create_experiment",
"neptune.append_tag",
"neptune.init"
] | [((16, 68), 'neptune.init', 'neptune.init', (['"""shared/onboarding"""'], {'api_token': '"""<KEY>"""'}), "('shared/onboarding', api_token='<KEY>')\n", (28, 68), False, 'import neptune\n'), ((75, 122), 'neptune.create_experiment', 'neptune.create_experiment', ([], {'name': '"""hello-neptune"""'}), "(name='hello-neptune'... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.init",
"neptune.new.types.File.as_image",
"neptune.new.types.File"
] | [((1343, 1398), 'neptune.new.init', 'neptune.init', ([], {'source_files': '"""alpha_integration_dev/*.py"""'}), "(source_files='alpha_integration_dev/*.py')\n", (1355, 1398), True, 'import neptune.new as neptune\n'), ((2638, 2652), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (2650, 2652), False, 'from da... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.internal.utils.alpha_integration.AlphaPropertyDTO.is_valid_attribute",
"neptune.new.internal.backends.operation_api_name_visitor.OperationApiNameVisitor",
"neptune.new.internal.operation.ConfigFloatSeries",
"neptune.internal.utils.alpha_integration.AlphaChannelDTO.is_valid_attribute",
"neptune.inte... | [((3608, 3635), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (3625, 3635), False, 'import logging\n'), ((3656, 3840), 'collections.namedtuple', 'namedtuple', (['"""LegacyExperiment"""', '"""shortId name timeOfCreation timeOfCompletion runningTime owner storageSize channelsSize tags desc... |
import os
import lightgbm as lgb
import neptune
from neptunecontrib.monitoring.lightgbm import neptune_monitor
from neptunecontrib.versioning.data import log_data_version
from neptunecontrib.api.utils import get_filepaths
from neptunecontrib.monitoring.reporting import send_binary_classification_report
from neptunecon... | [
"neptune.send_metric",
"neptune.send_artifact",
"neptune.init"
] | [((610, 626), 'src.utils.check_env_vars', 'check_env_vars', ([], {}), '()\n', (624, 626), False, 'from src.utils import read_config, check_env_vars\n'), ((687, 738), 'neptune.init', 'neptune.init', ([], {'project_qualified_name': 'CONFIG.project'}), '(project_qualified_name=CONFIG.project)\n', (699, 738), False, 'impor... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.get_project",
"neptune.new.init",
"neptune.new.init_project"
] | [((794, 801), 'faker.Faker', 'Faker', ([], {}), '()\n', (799, 801), False, 'from faker import Faker\n'), ((943, 984), 'neptune.new.init', 'neptune.init', ([], {'project': 'environment.project'}), '(project=environment.project)\n', (955, 984), True, 'import neptune.new as neptune\n'), ((1162, 1222), 'neptune.new.init', ... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.init_model_version",
"neptune.new.internal.backends.api_model.StringAttribute",
"neptune.new.internal.backends.api_model.IntAttribute",
"neptune.new.internal.backends.api_model.Attribute"
] | [((1474, 1485), 'tests.neptune.new.utils.api_experiments_factory.api_model', 'api_model', ([], {}), '()\n', (1483, 1485), False, 'from tests.neptune.new.utils.api_experiments_factory import api_model, api_model_version\n'), ((1509, 1528), 'tests.neptune.new.utils.api_experiments_factory.api_model_version', 'api_model_v... |
import neptune.new as neptune
import os
import matplotlib.pyplot as plt
# sgd 411, 412, 413
# adam 414, 415, 416
token = os.getenv('Neptune_api')
run1 = neptune.init(
project="NTLAB/artifact-rej-scalp",
api_token=token,
run="AR1-439"
) # adam 1
adam1_rate = run1['network_ADAM/learning_rate'].fetch_value... | [
"neptune.new.init"
] | [((124, 148), 'os.getenv', 'os.getenv', (['"""Neptune_api"""'], {}), "('Neptune_api')\n", (133, 148), False, 'import os\n'), ((156, 241), 'neptune.new.init', 'neptune.init', ([], {'project': '"""NTLAB/artifact-rej-scalp"""', 'api_token': 'token', 'run': '"""AR1-439"""'}), "(project='NTLAB/artifact-rej-scalp', api_token... |
import hashlib
import os
import tempfile
import matplotlib.pyplot as plt
import neptune
import numpy as np
import optuna
import tensorflow as tf
from tensorflow import keras
def log_data(logs):
neptune.log_metric('epoch_accuracy', logs['accuracy'])
neptune.log_metric('epoch_loss', logs['loss'])
def train_e... | [
"neptune.log_metric",
"neptune.create_experiment",
"neptune.set_property",
"neptune.init",
"neptune.log_text",
"neptune.stop",
"neptune.log_artifact"
] | [((5519, 5559), 'neptune.init', 'neptune.init', (['"""USERNAME/example-project"""'], {}), "('USERNAME/example-project')\n", (5531, 5559), False, 'import neptune\n'), ((5589, 5723), 'optuna.create_study', 'optuna.create_study', ([], {'study_name': '"""classification"""', 'direction': '"""maximize"""', 'storage': '"""sql... |
import torch
import torch.nn as nn
from torch.distributions import Categorical
import numpy as np
import gym
import lolgym.envs
from pylol.lib import actions, features, point
from pylol.lib import point
from absl import flags
FLAGS = flags.FLAGS
_NO_OP = [actions.FUNCTIONS.no_op.id]
_MOVE = [actions.FU... | [
"neptune.new.init"
] | [((595, 749), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""config_dirs"""', '"""/mnt/c/Users/win8t/Desktop/pylol/config.txt"""', '"""Path to file containing GameServer and LoL Client directories"""'], {}), "('config_dirs',\n '/mnt/c/Users/win8t/Desktop/pylol/config.txt',\n 'Path to file containing Gam... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.backends.utils.ssl_verify",
"neptune.management.exceptions.BadRequestException",
"neptune.management.internal.dto.ProjectVisibilityDTO.from_str",
"neptune.management.exceptions.ProjectsLimitReached",
"neptune.new.internal.backends.hosted_client.create_backend_client",
"neptune.manage... | [((2289, 2364), 'neptune.new.internal.backends.hosted_client.create_backend_client', 'create_backend_client', ([], {'client_config': 'client_config', 'http_client': 'http_client'}), '(client_config=client_config, http_client=http_client)\n', (2310, 2364), False, 'from neptune.new.internal.backends.hosted_client import ... |
import os
import re
import string
from typing import Tuple
import flytekit
from flytekit import task, workflow, Secret, Resources
from flytekit.types.directory import FlyteDirectory
from flytekitplugins.kftensorflow import TfJob
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras import lo... | [
"neptune.new.integrations.tensorflow_keras.NeptuneCallback"
] | [((750, 823), 'flytekit.Resources', 'Resources', ([], {'gpu': '"""2"""', 'mem': '"""10Gi"""', 'storage': '"""10Gi"""', 'ephemeral_storage': '"""500Mi"""'}), "(gpu='2', mem='10Gi', storage='10Gi', ephemeral_storage='500Mi')\n", (759, 823), False, 'from flytekit import task, workflow, Secret, Resources\n'), ((2930, 2978)... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.types.series.file_series.FileSeries",
"neptune.new.internal.operation.ClearImageLog",
"neptune.new.internal.utils.base64_encode",
"neptune.utils.split_to_chunks",
"neptune.new.exceptions.FileNotFound",
"neptune.new.internal.operation.LogImages",
"neptune.new.exceptions.OperationNotSupported... | [((1850, 1875), 'neptune.new.internal.operation.ClearImageLog', 'ClearImageLog', (['self._path'], {}), '(self._path)\n', (1863, 1875), False, 'from neptune.new.internal.operation import ImageValue, LogImages, ClearImageLog, Operation\n'), ((1957, 1988), 'neptune.new.types.series.file_series.FileSeries', 'FileSeriesVal'... |
#
# Copyright (c) 2021, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.get_project",
"neptune.new.init_project",
"neptune.new.init_run",
"neptune.new.init_model"
] | [((3055, 3117), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""container"""', "['model']"], {'indirect': '(True)'}), "('container', ['model'], indirect=True)\n", (3078, 3117), False, 'import pytest\n'), ((3443, 3506), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""container_type"""', 'AVAILABL... |
import neptune.new as neptune
data_version = "5b49383080a7edfe4ef72dc359112d3c"
base_namespace = "production"
# (neptune) fetch project
project = neptune.get_project(name="common/project-tabular-data")
# (neptune) find best run for given data version
best_run_df = project.fetch_runs_table(tag="best-finetuned").to_pa... | [
"neptune.new.get_project",
"neptune.new.init"
] | [((148, 203), 'neptune.new.get_project', 'neptune.get_project', ([], {'name': '"""common/project-tabular-data"""'}), "(name='common/project-tabular-data')\n", (167, 203), True, 'import neptune.new as neptune\n'), ((485, 589), 'neptune.new.init', 'neptune.init', ([], {'project': '"""common/project-tabular-data"""', 'run... |
import neptune.new as neptune
import time
from metrics import calculate_counter, calculate_classification, calculate_counter135
from models.shapes_classifier import ShapesClassifier
from models.shapes_counter import ShapesCounter, ShapesCounter135
tracked_values = ['train/loss',
'train/acc',
... | [
"neptune.new.init"
] | [((593, 711), 'neptune.new.init', 'neptune.init', ([], {'project': '"""uw-niedziol/dl-shapes"""', 'source_files': "['*.py', 'models/*.py', 'datasets/*.py']", 'tags': '[model]'}), "(project='uw-niedziol/dl-shapes', source_files=['*.py',\n 'models/*.py', 'datasets/*.py'], tags=[model])\n", (605, 711), True, 'import ne... |
import neptune.new as neptune
import os
from GTApack.GTA_hotloader import GTA_hotloader
from GTApack.GTA_antihot import GTA_antihot
from GTApack.GTA_Unet import GTA_Unet
from GTApack.GTA_prop_to_hot import GTA_prop_to_hot
from GTApack.GTA_tester import GTA_tester
from torchvision import datasets, transforms
from torch... | [
"neptune.new.init",
"neptune.new.types.File"
] | [((797, 815), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (811, 815), True, 'import numpy as np\n'), ((1078, 1121), 'numpy.random.randint', 'np.random.randint', ([], {'low': '(1)', 'high': '(856)', 'size': '(20)'}), '(low=1, high=856, size=20)\n', (1095, 1121), True, 'import numpy as np\n'), ((1147... |
#
# Copyright (c) 2016, deepsense.io
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in w... | [
"neptune.internal.common.utils.browser.SilentBrowser",
"neptune.internal.common.utils.browser.NullBrowser",
"neptune.internal.common.config.neptune_config.load_bool_env",
"neptune.internal.cli.commands.data.upload.DataUpload",
"neptune.internal.cli.commands.data.remove.DataRemove",
"neptune.internal.cli.c... | [((5445, 5546), 'neptune.internal.cli.commands.framework.CommandExecutionContext', 'CommandExecutionContext', ([], {'api_service': 'self._api_service', 'config': 'self._config', 'session': 'self.session'}), '(api_service=self._api_service, config=self._config,\n session=self.session)\n', (5468, 5546), False, 'from n... |
# -*- coding: utf-8 -*-
#
# Copyright (c) 2017, deepsense.io
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicab... | [
"neptune.internal.common.api.exceptions.NeptuneUnprocessableEntityException",
"neptune.internal.common.api.exceptions.ServerTimedOutException",
"neptune.internal.common.api.exceptions.NeptuneEntityNotFoundException",
"neptune.internal.common.api.exceptions.NeptuneServerRequestFailedException",
"neptune.inte... | [((1346, 1373), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1363, 1373), False, 'import logging\n'), ((2327, 2357), 'future.utils.iteritems', 'iteritems', (['model.swagger_types'], {}), '(model.swagger_types)\n', (2336, 2357), False, 'from future.utils import raise_from, iteritems\n')... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.utils.verify_collection_type",
"neptune.new.internal.utils.paths.parse_path",
"neptune.new.internal.utils.is_float_like",
"neptune.new.internal.utils.is_float",
"neptune.new.types.atoms.file.File.is_convertable",
"neptune.new.internal.utils.is_string",
"neptune.new.internal.utils.i... | [((2473, 2499), 'neptune.new.types.atoms.file.File.create_from', 'FileVal.create_from', (['value'], {}), '(value)\n', (2492, 2499), True, 'from neptune.new.types.atoms.file import File as FileVal\n'), ((2935, 2955), 'neptune.new.internal.utils.is_collection', 'is_collection', (['value'], {}), '(value)\n', (2948, 2955),... |
import neptune.new as neptune
# download runs table from Neptune
my_project = neptune.get_project(name="common/colab-test-run", api_token="<PASSWORD>")
run_df = my_project.fetch_runs_table(tag=["advanced"]).to_pandas()
run_df.head()
# resume run
run = neptune.init(project="common/colab-test-run", api_token="<PASSWORD... | [
"neptune.new.get_project",
"neptune.new.init"
] | [((79, 152), 'neptune.new.get_project', 'neptune.get_project', ([], {'name': '"""common/colab-test-run"""', 'api_token': '"""<PASSWORD>"""'}), "(name='common/colab-test-run', api_token='<PASSWORD>')\n", (98, 152), True, 'import neptune.new as neptune\n'), ((254, 341), 'neptune.new.init', 'neptune.init', ([], {'project'... |
#
# Copyright (c) 2022, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.backends.api_model.IntAttribute",
"neptune.new.get_last_run",
"neptune.new.init_run",
"neptune.new.internal.backends.api_model.Attribute"
] | [((1362, 1371), 'tests.neptune.new.utils.api_experiments_factory.api_run', 'api_run', ([], {}), '()\n', (1369, 1371), False, 'from tests.neptune.new.utils.api_experiments_factory import api_run\n'), ((1375, 1466), 'mock.patch', 'patch', (['"""neptune.new.internal.backends.factory.HostedNeptuneBackend"""', 'NeptuneBacke... |
import neptune.new as neptune
run = neptune.init(project="common/colab-test-run", api_token="<PASSWORD>")
params = {"learning_rate": 0.1}
# log params
run["parameters"] = params
# log name and append tags
run["sys/name"] = "basic-colab-example"
run["sys/tags"].add(["colab", "intro"])
# log loss during training
for... | [
"neptune.new.init"
] | [((37, 106), 'neptune.new.init', 'neptune.init', ([], {'project': '"""common/colab-test-run"""', 'api_token': '"""<PASSWORD>"""'}), "(project='common/colab-test-run', api_token='<PASSWORD>')\n", (49, 106), True, 'import neptune.new as neptune\n')] |
"""
Log using `neptune <https://www.neptune.ml>`_
Neptune logger can be used in the online mode or offline (silent) mode.
To log experiment data in online mode, NeptuneLogger requries an API key:
.. code-block:: python
from pytorch_lightning.logging import NeptuneLogger
# arguments made to NeptuneLogger are ... | [
"neptune.OfflineBackend",
"neptune.create_experiment",
"neptune.init"
] | [((1927, 1946), 'logging.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (1936, 1946), False, 'from logging import getLogger\n'), ((6715, 6793), 'neptune.init', 'neptune.init', ([], {'api_token': 'self.api_key', 'project_qualified_name': 'self.project_name'}), '(api_token=self.api_key, project_qualified_na... |
"""Implement a callback to log images."""
# =============================================================================
# Copyright 2021 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License... | [
"neptune.new.types.File.as_image"
] | [((1712, 1728), 'ptlflow.utils.utils.config_logging', 'config_logging', ([], {}), '()\n', (1726, 1728), False, 'from ptlflow.utils.utils import config_logging\n'), ((10498, 10520), 'PIL.Image.fromarray', 'Image.fromarray', (['image'], {}), '(image)\n', (10513, 10520), False, 'from PIL import Image, ImageDraw, ImageFont... |
from typing import Dict, List
import neptune
from catalyst.core.callback import (
Callback,
CallbackNode,
CallbackOrder,
CallbackScope,
)
from catalyst.core.runner import IRunner
class NeptuneLogger(Callback):
"""Logger callback, translates ``runner.*_metrics`` to Neptune.
Read about Neptune... | [
"neptune.create_experiment",
"neptune.init",
"neptune.OfflineBackend"
] | [((3817, 3860), 'neptune.create_experiment', 'neptune.create_experiment', ([], {}), '(**logging_params)\n', (3842, 3860), False, 'import neptune\n'), ((3552, 3663), 'neptune.init', 'neptune.init', ([], {'api_token': "logging_params['api_token']", 'project_qualified_name': "logging_params['project_name']"}), "(api_token... |
#
# Copyright (c) 2019, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.utils.images.get_image_content",
"neptune.new.internal.utils.images.get_html_content"
] | [((1154, 1175), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (1168, 1175), False, 'import matplotlib\n'), ((4060, 4133), 'unittest.skipIf', 'unittest.skipIf', (['IS_WINDOWS', '"""Installing Torch on Windows takes too long"""'], {}), "(IS_WINDOWS, 'Installing Torch on Windows takes too long')\n"... |
import os
import neptune
import pandas as pd
from src.features.utils import md5_hash, get_filepaths
APPLICATION_FEATURES_PATH = 'data/interim/application_features.csv'
BUREAU_FEATURES_PATH = 'data/interim/bureau_features.csv'
PROCESSED_FEATURES_FILEPATH = 'data/processed/features_joined_v1.csv'
NROWS=None
def main... | [
"neptune.set_property"
] | [((766, 840), 'pandas.read_csv', 'pd.read_csv', (['interim_feature_paths[0]'], {'usecols': "['SK_ID_CURR']", 'nrows': 'NROWS'}), "(interim_feature_paths[0], usecols=['SK_ID_CURR'], nrows=NROWS)\n", (777, 840), True, 'import pandas as pd\n'), ((1152, 1218), 'neptune.set_property', 'neptune.set_property', (['"""features_... |
import os
import pandas as pd
import models
import data
import generator as gen
import json
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
import multiprocessing
from _common import utils
from _common import callbacks as cbs
impo... | [
"neptune.send_artifact",
"neptune.init"
] | [((345, 435), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""train and evaluate YOLOv3 model on any dataset"""'}), "(description=\n 'train and evaluate YOLOv3 model on any dataset')\n", (368, 435), False, 'import argparse\n'), ((638, 669), 'neptune.init', 'neptune.init', (['"""kail4ek... |
import torch.nn as nn
import torch.utils
import torch.nn.functional as F
import torchvision.datasets as dset
import torch.backends.cudnn as cudnn
import numpy as np
import pandas as pd
from tqdm import tqdm
import neptune
import random
import os
import glob
import torch
import utils
import logging
from model_meta... | [
"neptune.init",
"neptune.send_metric",
"neptune.set_property",
"neptune.create_experiment"
] | [((374, 391), 'utils.read_yaml', 'utils.read_yaml', ([], {}), '()\n', (389, 391), False, 'import utils\n'), ((451, 460), 'utils.timestr', 'timestr', ([], {}), '()\n', (458, 460), False, 'from utils import timestr\n'), ((465, 502), 'neptune.set_property', 'neptune.set_property', (['"""Time Str"""', 'now'], {}), "('Time ... |
"""
Train a model on miniImageNet.
"""
import random
import neptune
import tensorflow as tf
from supervised_reptile.args import model_kwargs, train_kwargs, evaluate_kwargs, neptune_args
from supervised_reptile.eval import evaluate
from supervised_reptile.models import ProgressiveMiniImageNetModel
from supervised_rep... | [
"neptune.Context"
] | [((484, 501), 'neptune.Context', 'neptune.Context', ([], {}), '()\n', (499, 501), False, 'import neptune\n'), ((853, 874), 'supervised_reptile.args.neptune_args', 'neptune_args', (['context'], {}), '(context)\n', (865, 874), False, 'from supervised_reptile.args import model_kwargs, train_kwargs, evaluate_kwargs, neptun... |
import neptune.new as neptune
import os
import torch.nn as nn
import torch
import torch.nn.functional as F
from torch.optim import SGD, Adam
from torch.utils.data import DataLoader, random_split
from torch.optim.lr_scheduler import CyclicLR
import torch.multiprocessing as mp
import numpy as np
import random
import sys... | [
"neptune.new.init"
] | [((321, 342), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (336, 342), False, 'import sys\n'), ((12959, 12980), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (12974, 12980), False, 'import sys\n'), ((633, 661), 'torch.multiprocessing.set_start_method', 'mp.set_start_meth... |
import argparse
import os
import random
import torch
from torch.optim import Adam
from runner.pretrain_trainer import PreTrainer
from model.neural_apprentice import SmilesGenerator, SmilesGeneratorHandler
from util.smiles.dataset import load_dataset
from util.smiles.char_dict import SmilesCharDictionary
import neptu... | [
"neptune.append_tag",
"neptune.init"
] | [((364, 472), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""pretrain"""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description='pretrain', formatter_class=argparse.\n ArgumentDefaultsHelpFormatter)\n", (387, 472), False, 'import argparse\n'), ((1356, 1371), 't... |
"""
Script to train model for next sentence prediction
"""
import os, sys
import logging
import json
import collections
import itertools
import argparse
from typing import *
import numpy as np
from sklearn import metrics
from scipy.special import softmax
import torch
import torch.nn as nn
import skorch
import skorc... | [
"neptune.init",
"neptune.create_experiment"
] | [((753, 777), 'sys.path.append', 'sys.path.append', (['SRC_DIR'], {}), '(SRC_DIR)\n', (768, 777), False, 'import os, sys\n'), ((875, 906), 'os.path.join', 'os.path.join', (['SRC_DIR', '"""models"""'], {}), "(SRC_DIR, 'models')\n", (887, 906), False, 'import os, sys\n'), ((914, 938), 'os.path.isdir', 'os.path.isdir', ([... |
import copy
import neptune
import numpy as np
import pommerman
import torch
from torch import nn
from pommerman.dqn import utils, utility
from pommerman.dqn.experience_replay import Memory, RecurrentMemory
from pommerman.dqn.nets.vdn import VDNMixer
class Arena:
"""Parent abstract Arena."""
def __init__(... | [
"neptune.send_metric"
] | [((798, 823), 'copy.deepcopy', 'copy.deepcopy', (['self.mixer'], {}), '(self.mixer)\n', (811, 823), False, 'import copy\n'), ((1151, 1163), 'torch.nn.MSELoss', 'nn.MSELoss', ([], {}), '()\n', (1161, 1163), False, 'from torch import nn\n'), ((2641, 2674), 'neptune.send_metric', 'neptune.send_metric', (['"""loss"""', 'lo... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.internal.threading.daemon.Daemon.ConnectionRetryWrapper"
] | [((842, 869), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (859, 869), False, 'import logging\n'), ((1637, 1798), 'neptune.new.internal.threading.daemon.Daemon.ConnectionRetryWrapper', 'Daemon.ConnectionRetryWrapper', ([], {'kill_message': '"""Killing Neptune ping thread. Your run\'s st... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.attributes.series.string_series.StringSeries"
] | [((820, 866), 'mock.patch', 'patch', (['"""time.time"""'], {'new': 'TestAttributeBase._now'}), "('time.time', new=TestAttributeBase._now)\n", (825, 866), False, 'from mock import patch, MagicMock\n'), ((1230, 1253), 'neptune.new.attributes.series.string_series.StringSeries', 'StringSeries', (['exp', 'path'], {}), '(exp... |
#
# Copyright (c) 2020, Neptune Labs Sp. z o.o.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agr... | [
"neptune.new.types.File.as_html",
"neptune.new.types.File.as_pickle",
"neptune.new.internal.utils.images._get_pil_image_data",
"neptune.new.types.File.from_stream",
"neptune.new.types.File.from_content",
"neptune.new.types.File.as_image",
"neptune.new.types.File"
] | [((986, 1007), 'neptune.new.types.File', 'File', (['"""some/path.ext"""'], {}), "('some/path.ext')\n", (990, 1007), False, 'from neptune.new.types import File\n'), ((1170, 1195), 'neptune.new.types.File', 'File', (['"""some/path.txt.ext"""'], {}), "('some/path.txt.ext')\n", (1174, 1195), False, 'from neptune.new.types ... |
# -*- coding: utf-8 -*-
import json
import os
import random
import click
import neptune
import numpy as np
import regex
import torch
from loguru import logger
from neptune.exceptions import NoExperimentContext
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset
from tqdm import tqd... | [
"neptune.stop",
"neptune.send_metric"
] | [((4406, 4421), 'click.command', 'click.command', ([], {}), '()\n', (4419, 4421), False, 'import click\n'), ((4740, 4815), 'click.option', 'click.option', (['"""--lstm_layers"""'], {'default': '(2)', 'show_default': '(True)', 'type': 'click.INT'}), "('--lstm_layers', default=2, show_default=True, type=click.INT)\n", (4... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.