code stringlengths 189 49.4k | apis list | extract_api stringlengths 107 64.3k |
|---|---|---|
# Copyright The PyTorch Lightning team.
#
# 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.OfflineBackend",
"neptune.Session.with_default_backend"
] | [((9545, 9646), 'pytorch_lightning._logger.info', 'log.info', (['f"""NeptuneLogger will work in {\'offline\' if self.offline_mode else \'online\'} mode"""'], {}), '(\n f"NeptuneLogger will work in {\'offline\' if self.offline_mode else \'online\'} mode"\n )\n', (9553, 9646), True, 'from pytorch_lightning import _... |
import neptune.new as neptune
import os
from GTApack.GTA_Unet import GTA_Unet
from GTApack.GTA_hotloader import GTA_hotloader
from GTApack.GTA_imageplot import GTA_imageplot
from GTApack.GTA_antihot import GTA_antihot
from GTApack.GTA_prop_to_hot import GTA_prop_to_hot
import torch
import numpy as np
#from collections... | [
"neptune.new.init"
] | [((362, 386), 'os.getenv', 'os.getenv', (['"""Neptune_api"""'], {}), "('Neptune_api')\n", (371, 386), False, 'import os\n'), ((393, 491), 'neptune.new.init', 'neptune.init', ([], {'project': '"""Deep-Learning-test/Deep-Learning-Test"""', 'api_token': 'token', 'run': '"""DEEP-35"""'}), "(project='Deep-Learning-test/Deep... |
#
# 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.container_structure.ContainerStructure",
"neptune.new.attributes.attribute.Attribute.__init__",
"neptune.new.types.namespace.Namespace",
"neptune.new.internal.utils.paths.path_to_str",
"neptune.new.internal.utils.paths.parse_path"
] | [((1365, 1406), 'neptune.new.attributes.attribute.Attribute.__init__', 'Attribute.__init__', (['self', 'container', 'path'], {}), '(self, container, path)\n', (1383, 1406), False, 'from neptune.new.attributes.attribute import Attribute\n'), ((1462, 1479), 'neptune.new.internal.utils.paths.path_to_str', 'path_to_str', (... |
import os
import subprocess
from PIL import Image
import neptune
DEFAULT_DATA_ROOT='/home/elijahc/projects/vae'
proj = neptune.set_project('elijahc/DuplexAE')
exp = proj.get_experiments(id=['DPX-65'])[0]
def model_dir(exp=exp,data_root=DEFAULT_DATA_ROOT):
mod_dir = os.path.join(*[
data_root,
ex... | [
"neptune.set_project"
] | [((121, 160), 'neptune.set_project', 'neptune.set_project', (['"""elijahc/DuplexAE"""'], {}), "('elijahc/DuplexAE')\n", (140, 160), False, 'import neptune\n'), ((601, 625), 'os.path.exists', 'os.path.exists', (['gif_path'], {}), '(gif_path)\n', (615, 625), False, 'import os\n'), ((807, 818), 'os.getcwd', 'os.getcwd', (... |
import os
import shutil
import neptune
import pandas as pd
import numpy as np
import math
import cv2
from PIL import Image
from .pipeline_config import DESIRED_CLASS_SUBSET, N_SUB_CLASSES, ID_COLUMN, LABEL_COLUMN, SEED, SOLUTION_CONFIG, \
NAMES2CODES, CODES2NAMES
from .pipelines import PIPELINES
from .utils impo... | [
"neptune.Context",
"neptune.Image"
] | [((600, 617), 'neptune.Context', 'neptune.Context', ([], {}), '()\n', (615, 617), False, 'import neptune\n'), ((4303, 4367), 'os.path.join', 'os.path.join', (['PARAMS.experiment_dir', '"""evaluation_prediction.csv"""'], {}), "(PARAMS.experiment_dir, 'evaluation_prediction.csv')\n", (4315, 4367), False, 'import os\n'), ... |
from functools import partial
import os
import shutil
from attrdict import AttrDict
import neptune
from neptunecontrib.api.utils import get_filepaths
import numpy as np
import pandas as pd
from sklearn.externals import joblib
from sklearn.metrics import roc_auc_score
from steppy.base import Step, IdentityOperation
fro... | [
"neptune.init",
"neptune.send_metric"
] | [((543, 565), 'common_blocks.utils.check_env_vars', 'utils.check_env_vars', ([], {}), '()\n', (563, 565), False, 'from common_blocks import utils\n'), ((640, 659), 'common_blocks.utils.init_logger', 'utils.init_logger', ([], {}), '()\n', (657, 659), False, 'from common_blocks import utils\n'), ((661, 712), 'neptune.ini... |
#
# 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.streams.std_stream_capture_logger.StderrCaptureLogger",
"neptune.new.internal.streams.std_stream_capture_logger.StdoutCaptureLogger"
] | [((1266, 1312), 'neptune.new.internal.streams.std_stream_capture_logger.StdoutCaptureLogger', 'StdoutCaptureLogger', (['run', 'self._attribute_name'], {}), '(run, self._attribute_name)\n', (1285, 1312), False, 'from neptune.new.internal.streams.std_stream_capture_logger import StdoutCaptureLogger, StderrCaptureLogger\n... |
"""
Usage:
run-study-niid-mnist.py
(--avg | --opt) --start-round=NUM --rounds=NUM
[--not-pure] [--attackers-num=num]
[--log] [--nep-log] [--output-prefix=NAME]
"""
from docopt import docopt
import os
import torch
import random
import neptune
import _pickle as pickle
import syft as sy
imp... | [
"neptune.create_experiment",
"neptune.stop",
"neptune.log_metric"
] | [((906, 921), 'docopt.docopt', 'docopt', (['__doc__'], {}), '(__doc__)\n', (912, 921), False, 'from docopt import docopt\n'), ((2976, 3000), 'collections.defaultdict', 'defaultdict', (['(lambda : [])'], {}), '(lambda : [])\n', (2987, 3000), False, 'from collections import defaultdict\n'), ((6772, 6814), 'federated_lear... |
#
# 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.internal.hardware.gauges.memory.SystemMemoryUsageGauge",
"neptune.internal.hardware.metrics.reports.metric_report.MetricValue",
"neptune.internal.hardware.gauges.cpu.SystemCpuUsageGauge",
"neptune.internal.hardware.metrics.service.metric_service_factory.MetricServiceFactory"
] | [((4203, 4218), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4216, 4218), False, 'import unittest\n'), ((1348, 1359), 'mock.MagicMock', 'MagicMock', ([], {}), '()\n', (1357, 1359), False, 'from mock import ANY, MagicMock, call\n'), ((1398, 1463), 'neptune.internal.hardware.metrics.service.metric_service_factory... |
#
# 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.model.LeaderboardEntry",
"neptune.experiments.Experiment"
] | [((11542, 11587), 'mock.patch', 'patch', (['"""neptune.projects.os.path"""'], {'new': 'ntpath'}), "('neptune.projects.os.path', new=ntpath)\n", (11547, 11587), False, 'from mock import MagicMock, patch\n'), ((11593, 11663), 'mock.patch', 'patch', (['"""neptune.internal.storage.storage_utils.os.sep"""'], {'new': 'ntpath... |
import hashlib
import lightgbm as lgb
import neptune.new as neptune
import pandas as pd
from neptune.new.integrations.lightgbm import NeptuneCallback, create_booster_summary
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OrdinalEncoder
# (neptune) create run
run = neptune.init(... | [
"neptune.new.init",
"neptune.new.integrations.lightgbm.create_booster_summary",
"neptune.new.integrations.lightgbm.NeptuneCallback"
] | [((307, 399), 'neptune.new.init', 'neptune.init', ([], {'project': '"""<WORKSPACE/PROJECT>"""', 'name': '"""titanic-training"""', 'tags': "['LightGBM']"}), "(project='<WORKSPACE/PROJECT>', name='titanic-training', tags=[\n 'LightGBM'])\n", (319, 399), True, 'import neptune.new as neptune\n'), ((429, 453), 'pandas.re... |
"""
script to train self-supervised MLM transformer model
Helpful links:
https://huggingface.co/transformers/model_doc/bert.html
https://colab.research.google.com/github/huggingface/blog/blob/master/notebooks/01_how_to_train.ipynb#scrollTo=he4SrUA8TohP
"""
import os, sys
import logging
import json
import itertools
im... | [
"neptune.create_experiment",
"neptune.init"
] | [((739, 763), 'sys.path.append', 'sys.path.append', (['SRC_DIR'], {}), '(SRC_DIR)\n', (754, 763), False, 'import os, sys\n'), ((880, 908), 'custom_metrics.load_blosum', 'custom_metrics.load_blosum', ([], {}), '()\n', (906, 908), False, 'import custom_metrics\n'), ((4820, 4925), 'argparse.ArgumentParser', 'argparse.Argu... |
import os
import time
import torch
import neptune
import numpy as np
import matplotlib.pyplot as plt
from monai.networks.utils import one_hot
from utils import class_count
class AverageMetricTracker:
"""Tracker that keeps track of average loss/scores over all batches in an epoch."""
# TODO: Simplify AverageM... | [
"neptune.log_metric"
] | [((1986, 2041), 'os.path.join', 'os.path.join', (['self.checkpoint_dir', 'self.checkpoint_name'], {}), '(self.checkpoint_dir, self.checkpoint_name)\n', (1998, 2041), False, 'import os\n'), ((2824, 2858), 'torch.nn.BCELoss', 'torch.nn.BCELoss', ([], {'reduction': '"""mean"""'}), "(reduction='mean')\n", (2840, 2858), Fal... |
"""
Saves predictions from a T5OCRBaseline, loading configs from a Neptune
Experiment. The model is loaded using the best experiment checkpoint.
The same preprocessing from finetuning phase is applied, using the operative
gin config uploaded to Neptune.
"""
from absl import app, flags, logging
from src.data.sroie impo... | [
"neptune.init"
] | [((1741, 1839), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""neptune_project"""', '"""marcospiau/final-project-ia376j-1"""', '"""Neptune project"""'], {}), "('neptune_project', 'marcospiau/final-project-ia376j-1',\n 'Neptune project')\n", (1760, 1839), False, 'from absl import app, flags, logging\n'), ((... |
#
# 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.ArtifactFileData",
"neptune.new.internal.artifacts.types.ArtifactDriversMap.match_path",
"neptune.new.internal.artifacts.drivers.s3.S3ArtifactDriver.download_file",
"neptune.new.internal.artifacts.types.ArtifactDriversMap.match_type",
"neptune.new.internal.artifacts.dri... | [((1200, 1218), 'boto3.client', 'boto3.client', (['"""s3"""'], {}), "('s3')\n", (1212, 1218), False, 'import boto3\n'), ((1301, 1342), 'datetime.datetime', 'datetime.datetime', (['(2021)', '(5)', '(23)', '(3)', '(55)', '(26)'], {}), '(2021, 5, 23, 3, 55, 26)\n', (1318, 1342), False, 'import datetime\n'), ((2064, 2254),... |
import gc
import tensorflow as tf
from spektral.data import BatchLoader
from spektral.transforms import GCNFilter, AdjToSpTensor
import neptune
from neptunecontrib.monitoring.keras import NeptuneMonitor
import model.gcn as model_gcn
import preprocess.utils as putils
import preprocess.general as pgeneral
class Expe... | [
"neptune.stop",
"neptune.create_experiment"
] | [((1182, 1281), 'preprocess.utils.build_vocab', 'putils.build_vocab', (["X_train_df['tokens']"], {'min_tf': 'MIN_TF', 'max_tf': 'MAX_TF', 'master_node': 'MASTER_NODE'}), "(X_train_df['tokens'], min_tf=MIN_TF, max_tf=MAX_TF,\n master_node=MASTER_NODE)\n", (1200, 1281), True, 'import preprocess.utils as putils\n'), ((... |
import os
import random
import time
import torch
import torch.backends.cudnn as cudnn
import models
from utils.logger import Logger
import yaml
import argparse
from utils import utils
import sys
def add_learner_params():
parser = argparse.ArgumentParser(description='ML')
parser.add_argument('--problem', defau... | [
"neptune.init",
"neptune.log_metric"
] | [((236, 277), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""ML"""'}), "(description='ML')\n", (259, 277), False, 'import argparse\n'), ((4350, 4389), 'utils.logger.Logger', 'Logger', (['"""logs"""'], {'base': 'args.root', 'fmt': 'fmt'}), "('logs', base=args.root, fmt=fmt)\n", (4356, 438... |
import math
import neptune
from archive.neptune_settings import NEPTUNE_API_TOKEN, NEPTUNE_PROJECT_NAME
neptune.init(project_qualified_name=NEPTUNE_PROJECT_NAME, api_token=NEPTUNE_API_TOKEN)
neptune.create_experiment(name='Test1')
for i in range(1000):
neptune.send_metric('metric_1', x=math.sin(i/100))
nept... | [
"neptune.init",
"neptune.stop",
"neptune.create_experiment"
] | [((107, 198), 'neptune.init', 'neptune.init', ([], {'project_qualified_name': 'NEPTUNE_PROJECT_NAME', 'api_token': 'NEPTUNE_API_TOKEN'}), '(project_qualified_name=NEPTUNE_PROJECT_NAME, api_token=\n NEPTUNE_API_TOKEN)\n', (119, 198), False, 'import neptune\n'), ((194, 233), 'neptune.create_experiment', 'neptune.creat... |
#
# 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.ClearStringSet",
"neptune.new.internal.utils.is_collection",
"neptune.new.internal.operation.AddStrings",
"neptune.new.internal.utils.verify_type",
"neptune.new.internal.utils.verify_collection_type"
] | [((1054, 1095), 'neptune.new.internal.utils.verify_type', 'verify_type', (['"""value"""', 'value', 'StringSetVal'], {}), "('value', value, StringSetVal)\n", (1065, 1095), False, 'from neptune.new.internal.utils import is_collection, verify_collection_type, verify_type\n'), ((2425, 2446), 'neptune.new.internal.utils.is_... |
import nltk
from mmr_filter import compute_maximal_marginal_relevance, process_LDA_topics, process_doc2vec_similarity, \
process_tfidf_similarity
from datasets import load_metric
import jsonlines
import argparse
import skopt
import neptune
import neptunecontrib.monitoring.skopt as sk_utils
nltk_tokenizer... | [
"neptune.init",
"neptune.create_experiment",
"neptune.stop"
] | [((323, 372), 'nltk.data.load', 'nltk.data.load', (['"""tokenizers/punkt/english.pickle"""'], {}), "('tokenizers/punkt/english.pickle')\n", (337, 372), False, 'import nltk\n'), ((4116, 4149), 'skopt.utils.use_named_args', 'skopt.utils.use_named_args', (['SPACE'], {}), '(SPACE)\n', (4142, 4149), False, 'import skopt\n')... |
#
# 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.sync.utils.create_dir_name"
] | [((2129, 2143), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (2141, 2143), False, 'from datetime import datetime\n'), ((1868, 1913), 'neptune.new.sync.utils.create_dir_name', 'create_dir_name', (['container_type', 'container_id'], {}), '(container_type, container_id)\n', (1883, 1913), False, 'from neptune... |
#
# 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.projects.Project",
"neptune.sessions.Session"
] | [((1187, 1211), 'mock.patch', 'patch', (['"""threading.RLock"""'], {}), "('threading.RLock')\n", (1192, 1211), False, 'from mock import MagicMock, patch\n'), ((914, 925), 'mock.MagicMock', 'MagicMock', ([], {}), '()\n', (923, 925), False, 'from mock import MagicMock, patch\n'), ((1043, 1054), 'mock.MagicMock', 'MagicMo... |
import copy
import neptune
import numpy as np
import pommerman
import torch
from torch import nn
from pommerman.dqn import utils, utility
from pommerman import constants
from pommerman.dqn.experience_replay import Memory, RecurrentMemory
from pommerman.dqn.nets.vdn import VDNMixer, CommVDNMixer
class CommArena:
... | [
"neptune.send_metric"
] | [((847, 872), 'copy.deepcopy', 'copy.deepcopy', (['self.mixer'], {}), '(self.mixer)\n', (860, 872), False, 'import copy\n'), ((964, 989), 'copy.deepcopy', 'copy.deepcopy', (['self.mixer'], {}), '(self.mixer)\n', (977, 989), False, 'import copy\n'), ((1476, 1488), 'torch.nn.MSELoss', 'nn.MSELoss', ([], {}), '()\n', (148... |
# -*- coding: utf-8 -*-
"""Wheat Detection EfficientDet.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1oZPgPkvJeJRuDvgeaPc2KDr8bDh-Pbjw
"""
"""## Setup"""
import os
import time
import datetime
import gc
import random
import numpy as np
import... | [
"neptune.create_experiment",
"neptune.init",
"neptune.set_project",
"neptune.stop",
"neptune.log_metric"
] | [((1523, 1550), 'pandas.read_csv', 'pd.read_csv', (['"""train_df.csv"""'], {}), "('train_df.csv')\n", (1534, 1550), True, 'import pandas as pd\n'), ((1562, 1589), 'pandas.read_csv', 'pd.read_csv', (['"""valid_df.csv"""'], {}), "('valid_df.csv')\n", (1573, 1589), True, 'import pandas as pd\n'), ((1704, 1747), 'getpass.g... |
# Import necessary libraries
import matplotlib.pyplot as plt
import neptune.new as neptune
import numpy as np
# Initialize Neptune and create a new run
run = neptune.init(api_token="<PASSWORD>", project="common/matplotlib-support")
# Create a sample chart
np.random.seed(42)
data = np.random.randn(2, 100)
figure, ax =... | [
"neptune.new.init",
"neptune.new.types.File.as_html",
"neptune.new.types.File.as_image"
] | [((159, 232), 'neptune.new.init', 'neptune.init', ([], {'api_token': '"""<PASSWORD>"""', 'project': '"""common/matplotlib-support"""'}), "(api_token='<PASSWORD>', project='common/matplotlib-support')\n", (171, 232), True, 'import neptune.new as neptune\n'), ((258, 276), 'numpy.random.seed', 'np.random.seed', (['(42)'],... |
import shutil
import os
import neptune
import re
import pandas as pd
from zipfile import ZipFile
from multiprocessing import Pool, cpu_count
import uuid
import json
import ffmpeg
def download_audios(index, project_name, exp_id):
print("----> downloading audios for ", exp_id)
api_token = os.environ["NEPTUNE_AP... | [
"neptune.Session.with_default_backend"
] | [((344, 401), 'neptune.Session.with_default_backend', 'neptune.Session.with_default_backend', ([], {'api_token': 'api_token'}), '(api_token=api_token)\n', (380, 401), False, 'import neptune\n'), ((529, 579), 'os.path.join', 'os.path.join', (['"""public/files"""', 'project_name', 'exp_id'], {}), "('public/files', projec... |
#
# 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.StringSeries",
"neptune.new.init",
"neptune.new.types.atoms.float.Float",
"neptune.new.types.atoms.string.String",
"neptune.new.types.series.FloatSeries"
] | [((1240, 1276), 'neptune.new.init', 'init', ([], {'mode': '"""debug"""', 'flush_period': '(0.5)'}), "(mode='debug', flush_period=0.5)\n", (1244, 1276), False, 'from neptune.new import ANONYMOUS, init\n'), ((1467, 1503), 'neptune.new.init', 'init', ([], {'mode': '"""debug"""', 'flush_period': '(0.5)'}), "(mode='debug', ... |
#
# Copyright (c) 2018, 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.cli.hardware.metrics.reports.metric_reporter_factory.MetricReporterFactory",
"neptune.internal.cli.hardware.gpu.gpu_monitor.GPUMonitor",
"neptune.internal.cli.hardware.metrics.metrics_factory.MetricsFactory",
"neptune.internal.cli.hardware.gauges.gauge_factory.GaugeFactory"
] | [((1714, 1749), 'neptune.internal.cli.hardware.gauges.gauge_factory.GaugeFactory', 'GaugeFactory', ([], {'gauge_mode': 'gauge_mode'}), '(gauge_mode=gauge_mode)\n', (1726, 1749), False, 'from neptune.internal.cli.hardware.gauges.gauge_factory import GaugeFactory\n'), ((1776, 1867), 'neptune.internal.cli.hardware.metrics... |
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'), ((638, 666), 'torch.multiprocessing.set_start_method', 'mp.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (657, 666), True, 'import torch.multiprocessing as mp\n'), ((850, 874), 'os.getenv',... |
import neptune
from automated_evaluation.cal_ppl import cal_ppl
from automated_evaluation.cal_dist import cal_dist
from automated_evaluation.cal_acc import cal_acc
def get_samples(src):
with open(src, 'r') as f:
return f.read().split('<|endoftext|>')[1:]
def startswith(string, prefixes):
for prefix ... | [
"neptune.init",
"neptune.create_experiment",
"neptune.stop",
"neptune.log_text"
] | [((2441, 2461), 'automated_evaluation.cal_ppl.cal_ppl', 'cal_ppl', (['pos_samples'], {}), '(pos_samples)\n', (2448, 2461), False, 'from automated_evaluation.cal_ppl import cal_ppl\n'), ((2476, 2496), 'automated_evaluation.cal_ppl.cal_ppl', 'cal_ppl', (['neg_samples'], {}), '(neg_samples)\n', (2483, 2496), False, 'from ... |
from cv2 import sepFilter2D
from torchvision import datasets
import numpy as np
import os
import matplotlib.pyplot as plt
import torch
import torch.nn.functional as F
from utils import zoom_image, get_device
from losses import relu_evidence
from model import RobocupModel
from torchvision.transforms import transforms, ... | [
"neptune.new.init"
] | [((6489, 6523), 'pytorch_lightning.seed_everything', 'seed_everything', (['(123)'], {'workers': '(True)'}), '(123, workers=True)\n', (6504, 6523), False, 'from pytorch_lightning import seed_everything\n'), ((6591, 6702), 'neptune.new.init', 'neptune.init', ([], {'api_token': "os.environ['NEPTUNE_API_TOKEN']", 'project'... |
from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
import neptune.new as neptune
run = neptune.init(project="common/quickstarts", api_token="<PASSWORD>")
data = load_wine()
X_train, X_test... | [
"neptune.new.init"
] | [((218, 284), 'neptune.new.init', 'neptune.init', ([], {'project': '"""common/quickstarts"""', 'api_token': '"""<PASSWORD>"""'}), "(project='common/quickstarts', api_token='<PASSWORD>')\n", (230, 284), True, 'import neptune.new as neptune\n'), ((293, 304), 'sklearn.datasets.load_wine', 'load_wine', ([], {}), '()\n', (3... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# In[211]:
import uuid
from pathlib import Path
import pandas_profiling
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import neptune.new as neptune
import neptune.new.types
import seaborn as sns
import sklearn.ensemble
import sklearn.metrics
import ... | [
"neptune.new.init",
"neptune.new.new.types.File.as_html"
] | [((449, 461), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (459, 461), False, 'import uuid\n'), ((555, 589), 'neptune.new.init', 'neptune.init', ([], {'name': 'f"""run_{run_id}"""'}), "(name=f'run_{run_id}')\n", (567, 589), True, 'import neptune.new as neptune\n'), ((719, 753), 'numpy.set_printoptions', 'np.set_printo... |
#
# 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",
"neptune.new.attributes.atoms.datetime.Datetime",
"neptune.new.attributes.atoms.artifact.Artifact",
"neptune.new.attributes.namespace.Namespace",
"neptune.new.attributes.sets.string_set.StringSet",
"neptune.new.attributes.atoms.file.File",
"nep... | [((2738, 2770), 'neptune.new.attributes.atoms.float.Float', 'FloatAttr', (['self._run', 'self._path'], {}), '(self._run, self._path)\n', (2747, 2770), True, 'from neptune.new.attributes.atoms.float import Float as FloatAttr\n'), ((2841, 2875), 'neptune.new.attributes.atoms.integer.Integer', 'IntegerAttr', (['self._run'... |
#
# 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.types.atoms.artifact.Artifact",
"neptune.new.attributes.atoms.artifact.Artifact"
] | [((1286, 1305), 'neptune.new.attributes.atoms.artifact.Artifact', 'Artifact', (['exp', 'path'], {}), '(exp, path)\n', (1294, 1305), False, 'from neptune.new.attributes.atoms.artifact import Artifact\n'), ((1837, 1856), 'neptune.new.attributes.atoms.artifact.Artifact', 'Artifact', (['exp', 'path'], {}), '(exp, path)\n',... |
#
# 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.exceptions.NeptuneException",
"neptune.api_exceptions.StorageLimitReached",
"neptune.api_exceptions.ExperimentNotFound"
] | [((922, 949), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (939, 949), False, 'import logging\n'), ((1691, 1699), 'functools.wraps', 'wraps', (['f'], {}), '(f)\n', (1696, 1699), False, 'from functools import wraps\n'), ((1829, 1968), 'neptune.exceptions.NeptuneException', 'NeptuneExcept... |
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, ReduceLROnPlateau
from tempfile import TemporaryDirectory
from sklearn.metrics i... | [
"neptune.send_metric"
] | [((6187, 6243), 'torch.optim.lr_scheduler.ExponentialLR', 'ExponentialLR', (['self.optimizer', 'self.gamma'], {'last_epoch': '(-1)'}), '(self.optimizer, self.gamma, last_epoch=-1)\n', (6200, 6243), False, 'from torch.optim.lr_scheduler import ExponentialLR, ReduceLROnPlateau\n'), ((7909, 8079), 'torch.optim.lr_schedule... |
import warnings
from typing import Callable, Sequence, Union
import neptune.new as neptune
import neptune.new.integrations.optuna as optuna_utils
import optuna
import pandas as pd
import yaml
from hydra.utils import to_absolute_path
from neptune.new.exceptions import NeptuneMissingApiTokenException
from optuna.integra... | [
"neptune.new.init",
"neptune.new.integrations.optuna.NeptuneCallback"
] | [((581, 614), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (604, 614), False, 'import warnings\n'), ((4089, 4150), 'optuna.integration.LightGBMPruningCallback', 'LightGBMPruningCallback', (['trial', '"""RMSPE"""'], {'valid_name': '"""valid_1"""'}), "(trial, 'RMSPE', vali... |
#!/usr/bin/env python
import multiprocessing as mp
import argparse
import copy
import yaml
import gym
import safety_gym
import time
from rltoolkit import EvalsWrapper, EvalsWrapperACM
from itertools import product
from print_obs_space import get_no_lidar_indexes, get_no_velocity_indexes, get_no_lidar_no_velocity_indexe... | [
"neptune.init",
"neptune.create_experiment",
"neptune.stop"
] | [((666, 680), 'safety_gym.envs.engine.Engine', 'Engine', (['config'], {}), '(config)\n', (672, 680), False, 'from safety_gym.envs.engine import Engine\n'), ((681, 796), 'gym.envs.registration.register', 'register', ([], {'id': '"""Safexp-DoggoColumns0-v0"""', 'entry_point': '"""safety_gym.envs.mujoco:Engine"""', 'kwarg... |
import warnings
from typing import Callable, Sequence, Union
import neptune.new as neptune
import neptune.new.integrations.optuna as optuna_utils
import optuna
import pandas as pd
import yaml
from hydra.utils import to_absolute_path
from models.boosting import train_and_evaluate
from neptune.new.exceptions import Nept... | [
"neptune.new.init",
"neptune.new.integrations.optuna.NeptuneCallback"
] | [((545, 578), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (568, 578), False, 'import warnings\n'), ((3630, 3670), 'models.boosting.train_and_evaluate', 'train_and_evaluate', (['params', 'train', 'valid'], {}), '(params, train, valid)\n', (3648, 3670), False, 'from model... |
import os
import argparse
import numpy as np
import torch
from torch.utils.data import DataLoader, Subset
import torchvision.models as models
import torchvision.utils as vutils
import torch.nn as nn
from tqdm import tqdm
from Dataset_CelebA import CelebA
from sklearn.metrics import f1_score
def train():
model.... | [
"neptune.init",
"neptune.log_metric"
] | [((2434, 2488), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""C0AE for CelebA"""'}), "(description='C0AE for CelebA')\n", (2457, 2488), False, 'import argparse\n'), ((3783, 3870), 'Dataset_CelebA.CelebA', 'CelebA', (['celeba_zip', 'celeba_txt', 'image_size'], {'fully_supervised': 'args.... |
import numpy as np
import neptune.new as neptune
class Logger:
'''
Logger class used to log data and generated samples using neptune, tensorboard, or saving the experiment to numpy arrays
'''
def __init__(self, configs):
self.var_names = []
self.data = {}
self.configs = con... | [
"neptune.new.init"
] | [((423, 546), 'neptune.new.init', 'neptune.init', (['configs.neptune_proj_name'], {'api_token': 'configs.api_token', 'source_files': "['**/*.py', '**/*.yaml', '**/*.yml']"}), "(configs.neptune_proj_name, api_token=configs.api_token,\n source_files=['**/*.py', '**/*.yaml', '**/*.yml'])\n", (435, 546), True, 'import n... |
import sys
import os
sys.path.append('..') # append parent folder to make import configs work
import configs
from DYME.src.dataset import Dataset
from DYME.src.models.dyme import DYME
from DYME.src.models.baseline import Baseline
import neptune
import pickle
from tqdm import tqdm
import torch
from torch import nn
f... | [
"neptune.create_experiment",
"neptune.log_text",
"neptune.init",
"neptune.log_metric"
] | [((21, 42), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (36, 42), False, 'import sys\n'), ((13232, 13283), 'neptune.log_metric', 'neptune.log_metric', (["('%s_loss' % metric_to_log)", 'loss'], {}), "('%s_loss' % metric_to_log, loss)\n", (13250, 13283), False, 'import neptune\n'), ((13834, 1388... |
import neptune
from torch import Tensor
from sonata.loggers import BaseLogger
class NeptuneLogger(BaseLogger):
def __init__(
self,
api_token,
project_name,
experiment_description=None,
experiment_name=None,
params=None,
):
se... | [
"neptune.init",
"neptune.create_experiment",
"neptune.log_metric"
] | [((333, 403), 'neptune.init', 'neptune.init', ([], {'project_qualified_name': 'project_name', 'api_token': 'api_token'}), '(project_qualified_name=project_name, api_token=api_token)\n', (345, 403), False, 'import neptune\n'), ((465, 527), 'neptune.create_experiment', 'neptune.create_experiment', ([], {'name': 'experime... |
#
# Copyright (c) 2021, self.experiment 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 la... | [
"neptune.Session"
] | [((960, 969), 'neptune.Session', 'Session', ([], {}), '()\n', (967, 969), False, 'from neptune import Session, envs\n'), ((1018, 1050), 'os.getenv', 'os.getenv', (['envs.PROJECT_ENV_NAME'], {}), '(envs.PROJECT_ENV_NAME)\n', (1027, 1050), False, 'import os\n'), ((2229, 2243), 'datetime.datetime.now', 'datetime.now', ([]... |
import argparse
import os
import os.path as osp
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import network
import loss
#import pre_process as prep
from torch.utils.data import DataLoader
import lr_schedule
import torch.nn.functional as F
import data_list
from data_list import Imag... | [
"neptune.create_experiment",
"neptune.init",
"neptune.append_tag",
"neptune.log_metric"
] | [((625, 637), 'torch.nn.functional.softmax', 'F.softmax', (['p'], {}), '(p)\n', (634, 637), True, 'import torch.nn.functional as F\n'), ((2990, 3014), 'torch.max', 'torch.max', (['all_output', '(1)'], {}), '(all_output, 1)\n', (2999, 3014), False, 'import torch\n'), ((4023, 4067), 'pre_process.image_train', 'prep.image... |
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
comet_cfg = EnvConfig()
session = neptune.Session(api_token=comet_cfg.neptune_token)
project = session.get_project(project_qualified_name=comet_cfg.neptune_project_... | [
"neptune.Session"
] | [((168, 179), 'config.EnvConfig', 'EnvConfig', ([], {}), '()\n', (177, 179), False, 'from config import EnvConfig\n'), ((190, 240), 'neptune.Session', 'neptune.Session', ([], {'api_token': 'comet_cfg.neptune_token'}), '(api_token=comet_cfg.neptune_token)\n', (205, 240), False, 'import neptune\n'), ((1281, 1293), 'matpl... |
#
# 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.internal.backends.hosted_neptune_backend.HostedNeptuneBackend",
"neptune.exceptions.InvalidNeptuneBackend",
"neptune.sessions.Session",
"neptune.exceptions.Uninitialized",
"neptune.internal.backends.offline_backend.OfflineBackend",
"neptune.exceptions.MissingProjectQualifiedName"
] | [((1120, 1137), 'threading.RLock', 'threading.RLock', ([], {}), '()\n', (1135, 1137), False, 'import threading\n'), ((1149, 1176), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1166, 1176), False, 'import logging\n'), ((4644, 4676), 'os.getenv', 'os.getenv', (['envs.PROJECT_ENV_NAME'], ... |
import warnings
from typing import Any, Callable, Dict, Optional
import neptune.new.integrations.lightgbm as nep_lgbm_utils
import neptune.new.integrations.xgboost as nep_xgb_utils
import pandas as pd
from catboost import CatBoostClassifier, Pool
from lightgbm import LGBMClassifier
from neptune.new import Run
from nep... | [
"neptune.new.integrations.lightgbm.NeptuneCallback",
"neptune.new.integrations.xgboost.NeptuneCallback"
] | [((490, 523), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (513, 523), False, 'import warnings\n'), ((1209, 1288), 'lightgbm.LGBMClassifier', 'LGBMClassifier', ([], {'random_state': 'self.config.model.seed'}), '(random_state=self.config.model.seed, **self.config.model.pa... |
import argparse
import math
from tqdm import tqdm
import operator
import numpy as np
import torchvision.utils as vutils
from torch.utils.data import Subset
from torch.utils.data import DataLoader
import torch.optim as optim
import torch.nn as nn
from torch.nn import functional as F
import torch
import random
import os
... | [
"neptune.init",
"neptune.log_metric"
] | [((524, 578), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""C0AE for CelebA"""'}), "(description='C0AE for CelebA')\n", (547, 578), False, 'import argparse\n'), ((4671, 4798), 'Dataset_CelebA.CelebA', 'CelebA', (['celeba_zip', 'celeba_txt', 'image_size'], {'fully_supervised': 'args.full... |
# %%
import sys
sys.path.append('../')
from pathlib import Path
from datetime import datetime
import pandas as pd
import torch
import torch.nn as nn
from torch import cuda
from torch.utils.data import Dataset, DataLoader
from transformers import DistilBertTokenizer, DistilBertModel
from config import settings
pri... | [
"neptune.new.init"
] | [((16, 38), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (31, 38), False, 'import sys\n'), ((691, 750), 'transformers.DistilBertTokenizer.from_pretrained', 'DistilBertTokenizer.from_pretrained', (['DISTIL_BERT_CHECKPOINT'], {}), '(DISTIL_BERT_CHECKPOINT)\n', (726, 750), False, 'from transform... |
import glob
from typing import Sequence
import neptune.new as neptune
import numpy as np
import omegaconf
import plotly.express as px
import plotly.graph_objects as go
from omegaconf import DictConfig, OmegaConf
from rich import print as printr
from rich.syntax import Syntax
from rich.tree import Tree
from sklearn.dec... | [
"neptune.new.init",
"neptune.new.types.File.as_html"
] | [((1473, 1525), 'omegaconf.OmegaConf.load', 'omegaconf.OmegaConf.load', (["(config_dir + '/basic.yaml')"], {}), "(config_dir + '/basic.yaml')\n", (1497, 1525), False, 'import omegaconf\n'), ((1626, 1729), 'neptune.new.init', 'neptune.init', ([], {'project': '"""vil/splitnet"""', 'name': '"""splitnet"""', 'tags': "['ben... |
#
# 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.StringSeries",
"neptune.new.init",
"neptune.new.types.atoms.float.Float",
"neptune.new.types.atoms.string.String",
"neptune.new.types.series.FloatSeries"
] | [((1190, 1226), 'neptune.new.init', 'init', ([], {'mode': '"""debug"""', 'flush_period': '(0.5)'}), "(mode='debug', flush_period=0.5)\n", (1194, 1226), False, 'from neptune.new import init, ANONYMOUS\n'), ((1417, 1453), 'neptune.new.init', 'init', ([], {'mode': '"""debug"""', 'flush_period': '(0.5)'}), "(mode='debug', ... |
#
# 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.sets.string_set.StringSetVal",
"neptune.new.internal.operation.ClearStringSet",
"neptune.new.internal.operation.AddStrings",
"neptune.new.internal.operation.RemoveStrings",
"neptune.new.attributes.sets.string_set.StringSet"
] | [((990, 1018), 'neptune.new.attributes.sets.string_set.StringSetVal', 'StringSetVal', (["['ert', 'qwe']"], {}), "(['ert', 'qwe'])\n", (1002, 1018), False, 'from neptune.new.attributes.sets.string_set import StringSet, StringSetVal\n'), ((1074, 1085), 'mock.MagicMock', 'MagicMock', ([], {}), '()\n', (1083, 1085), False,... |
## predict iris dataset
## imports
import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import neptune
import os
from dotenv import load_dotenv
load_dotenv()
## setup neptune account
NEPTUNE_API_KEY... | [
"neptune.init",
"neptune.create_experiment",
"neptune.stop"
] | [((265, 278), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (276, 278), False, 'from dotenv import load_dotenv\n'), ((321, 351), 'os.getenv', 'os.getenv', (['"""NEPTUNE_API_TOKEN"""'], {}), "('NEPTUNE_API_TOKEN')\n", (330, 351), False, 'import os\n'), ((352, 447), 'neptune.init', 'neptune.init', ([], {'project... |
#
# 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",
"neptune.new.internal.operation.LogFloats.ValueType",
"neptune.new.attributes.series.float_series.FloatSeriesVal",
"neptune.new.internal.operation.LogFloats",
"neptune.new.attributes.series.string_series.StringSeriesVal",
"neptune.new.internal.op... | [((1134, 1180), 'mock.patch', 'patch', (['"""time.time"""'], {'new': 'TestAttributeBase._now'}), "('time.time', new=TestAttributeBase._now)\n", (1139, 1180), False, 'from mock import MagicMock, call, patch\n'), ((1262, 1313), 'neptune.new.attributes.series.float_series.FloatSeriesVal', 'FloatSeriesVal', (['[17, 3.6]'],... |
#!/usr/bin/env python3
import numpy as np
import os
import torch
from torch import nn
import torch.nn.functional as F
import pytorch_lightning as pl
from predict_pv_yield.netcdf_dataset import NetCDFDataset, worker_init_fn
from predict_pv_yield.visualisation import plot_example
from neptune.new.integrations.pytorch... | [
"neptune.new.integrations.pytorch_lightning.NeptuneLogger",
"neptune.new.types.File.as_image"
] | [((403, 424), 'logging.basicConfig', 'logging.basicConfig', ([], {}), '()\n', (422, 424), False, 'import logging\n'), ((432, 469), 'logging.getLogger', 'logging.getLogger', (['"""predict_pv_yield"""'], {}), "('predict_pv_yield')\n", (449, 469), False, 'import logging\n'), ((960, 978), 'numpy.float32', 'np.float32', (['... |
import os
import neptune
import neptunecontrib.monitoring.skopt as sk_utils
from skopt import BayesSearchCV
from skopt import dump
from skopt.space import Real, Integer
from MLModule.metric import DimScoreModes, DimScore
from MLModule.utils import set_seed, neptune_api_token, neptune_proj_name
Search_Spac... | [
"neptune.init",
"neptune.create_experiment",
"neptune.stop"
] | [((350, 381), 'skopt.space.Real', 'Real', (['(0.0)', '(0.5)'], {'prior': '"""uniform"""'}), "(0.0, 0.5, prior='uniform')\n", (354, 381), False, 'from skopt.space import Real, Integer\n'), ((406, 440), 'skopt.space.Integer', 'Integer', (['(20)', '(4000)'], {'prior': '"""uniform"""'}), "(20, 4000, prior='uniform')\n", (4... |
#
# 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.internal.utils.image._get_pil_image_data",
"neptune.internal.utils.image._get_figure_as_image",
"neptune.internal.utils.image.get_image_content"
] | [((669, 690), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (683, 690), False, 'import matplotlib\n'), ((4447, 4545), 'unittest.skipIf', 'unittest.skipIf', (['(sys.version_info < (3, 6))'], {'reason': '"""Tensorflow isn\'t built for older Pythons"""'}), '(sys.version_info < (3, 6), reason=\n ... |
import os
import neptune
from neptunecontrib.monitoring.utils import axes2fig
import matplotlib.pyplot as plt
import pandas as pd
import skopt.plots
from src.features.utils import md5_hash, get_filepaths
from train_lgbm import train_evaluate
TRAIN_IDX_PATH = 'data/processed/train_idx.csv'
VALID_IDX_PATH = 'data/proc... | [
"neptune.send_metric"
] | [((1293, 1344), 'neptune.send_metric', 'neptune.send_metric', (['"""run_score"""', 'res.func_vals[-1]'], {}), "('run_score', res.func_vals[-1])\n", (1312, 1344), False, 'import neptune\n'), ((1583, 1623), 'pandas.read_csv', 'pd.read_csv', (['TRAIN_IDX_PATH'], {'nrows': 'NROWS'}), '(TRAIN_IDX_PATH, nrows=NROWS)\n', (159... |
#
# 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.NeptuneRunResumeAndCustomIdCollision",
"neptune.new.internal.notebooks.notebooks.create_checkpoint",
"neptune.new.types.mode.Mode",
"neptune.new.internal.utils.source_code.upload_source_code",
"neptune.new.internal.id_formats.QualifiedName",
"neptune.new.exceptions.NeptunePossibleL... | [((9868, 9898), 'neptune.new.internal.utils.verify_type', 'verify_type', (['"""mode"""', 'mode', 'str'], {}), "('mode', mode, str)\n", (9879, 9898), False, 'from neptune.new.internal.utils import verify_collection_type, verify_type\n'), ((10015, 10066), 'neptune.new.internal.utils.verify_type', 'verify_type', (['"""cap... |
# Copyright 2019 Xilinx Inc.
#
# 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 writing... | [
"neptune.neptune_api.NeptuneService",
"neptune.tests.conftest.get_server_addr"
] | [((708, 728), 'pytest.mark.fpgas', 'pytest.mark.fpgas', (['(1)'], {}), '(1)\n', (725, 728), False, 'import pytest\n'), ((908, 939), 'neptune.tests.conftest.get_server_addr', 'get_server_addr', (['request.config'], {}), '(request.config)\n', (923, 939), False, 'from neptune.tests.conftest import get_server_addr\n'), ((9... |
import argparse
import torch
import torch.nn as nn
from torch.utils import data, model_zoo
import numpy as np
import pickle
from torch.autograd import Variable
import torch.optim as optim
import scipy.misc
import torch.backends.cudnn as cudnn
import torch.nn.functional as F
import sys
import os
import os.path as osp
im... | [
"neptune.create_experiment",
"neptune.init",
"neptune.log_metric"
] | [((763, 833), 'numpy.array', 'np.array', (['(104.00698793, 116.66876762, 122.67891434)'], {'dtype': 'np.float32'}), '((104.00698793, 116.66876762, 122.67891434), dtype=np.float32)\n', (771, 833), True, 'import numpy as np\n'), ((1802, 1863), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '""... |
#
# 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.init",
"neptune.new.types.File.as_image"
] | [((7070, 7101), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (7084, 7101), False, 'import pytest\n'), ((7345, 7424), 'neptune.new.init', 'neptune.init', ([], {'name': '"""Integration pytorch-lightning"""', 'project': 'environment.project'}), "(name='Integration pytorch-li... |
import argparse
import warnings
import neptune.new as neptune
import pandas as pd
from neptune.new.integrations.xgboost import NeptuneCallback
from xgboost import XGBRegressor
from data.dataset import load_dataset
warnings.filterwarnings("ignore")
def define_argparser():
parse = argparse.ArgumentParser("Traini... | [
"neptune.new.init",
"neptune.new.integrations.xgboost.NeptuneCallback"
] | [((217, 250), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (240, 250), False, 'import warnings\n'), ((289, 325), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""Training!"""'], {}), "('Training!')\n", (312, 325), False, 'import argparse\n'), ((796, 814), 'dat... |
#
# 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.AssignBool",
"neptune.new.types.atoms.boolean.Boolean"
] | [((957, 974), 'neptune.new.types.atoms.boolean.Boolean', 'BooleanVal', (['value'], {}), '(value)\n', (967, 974), True, 'from neptune.new.types.atoms.boolean import Boolean as BooleanVal\n'), ((1043, 1078), 'neptune.new.internal.operation.AssignBool', 'AssignBool', (['self._path', 'value.value'], {}), '(self._path, valu... |
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"
] | [((547, 571), 'os.getenv', 'os.getenv', (['"""Neptune_api"""'], {}), "('Neptune_api')\n", (556, 571), False, 'import os\n'), ((573, 591), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (587, 591), True, 'import numpy as np\n'), ((599, 677), 'neptune.new.init', 'neptune.init', ([], {'project': '"""Deep... |
#
# 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.types.File.as_html",
"neptune.new.types.File.as_image",
"neptune.new.types.File.as_pickle",
"neptune.new.types.FileSeries"
] | [((3600, 3623), 'sklearn.base.is_regressor', 'is_regressor', (['regressor'], {}), '(regressor)\n', (3612, 3623), False, 'from sklearn.base import is_regressor, is_classifier\n'), ((6999, 7024), 'sklearn.base.is_classifier', 'is_classifier', (['classifier'], {}), '(classifier)\n', (7012, 7024), False, 'from sklearn.base... |
# Training using resnet
import numpy as np
import images as images
import torch
from torch.optim import SGD
from torchvision.models import resnet18
from torchvision import transforms
from torch.utils import data
import copy
import pandas as pd
import os
import neptune
if torch.cuda.is_available():
dev = "cuda:0"
... | [
"neptune.create_experiment",
"neptune.stop",
"neptune.log_artifact",
"neptune.log_metric"
] | [((274, 299), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (297, 299), False, 'import torch\n'), ((370, 400), 'os.getenv', 'os.getenv', (['"""NEPTUNE_API_TOKEN"""'], {}), "('NEPTUNE_API_TOKEN')\n", (379, 400), False, 'import os\n'), ((748, 771), 'images.get_data_files', 'images.get_data_files... |
# %% markdown
## DISEASE DETECTOR FAST R-CNN
# %% codecell
# Para activar el directorio como path para cargar como módulos
# cuando se obtiene: 'No module named X'
import sys
sys.path.append('D:/GitHub/Mariuki/DiseaseDetector/Detector de Padecimientos Rayos-X Torax - Codigo')
sys.path
# import _openssl error: (DLLS)
#... | [
"neptune.init"
] | [((176, 287), 'sys.path.append', 'sys.path.append', (['"""D:/GitHub/Mariuki/DiseaseDetector/Detector de Padecimientos Rayos-X Torax - Codigo"""'], {}), "(\n 'D:/GitHub/Mariuki/DiseaseDetector/Detector de Padecimientos Rayos-X Torax - Codigo'\n )\n", (191, 287), False, 'import sys\n'), ((828, 888), 'pathlib.Path',... |
import warnings
from typing import Any, Callable, Dict, Optional
import neptune.new.integrations.lightgbm as nep_lgbm_utils
import pandas as pd
from lightgbm import LGBMRegressor
from neptune.new import Run
from neptune.new.integrations.lightgbm import create_booster_summary
from model.base import BaseModel
warnings... | [
"neptune.new.integrations.lightgbm.NeptuneCallback"
] | [((312, 345), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (335, 345), False, 'import warnings\n'), ((1030, 1108), 'lightgbm.LGBMRegressor', 'LGBMRegressor', ([], {'random_state': 'self.config.model.seed'}), '(random_state=self.config.model.seed, **self.config.model.para... |
import json
import logging
import os
import random
import time
import tornado.ioloop
import numpy as np
from neptune.service_manager import ServiceManager
logger = logging.getLogger(__name__)
async def image_handler(self):
requestId = self.application.request_id_gen.get()
img = self.get_argument('image', No... | [
"neptune.service_manager.ServiceManager"
] | [((167, 194), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (184, 194), False, 'import logging\n'), ((522, 537), 'json.loads', 'json.loads', (['img'], {}), '(img)\n', (532, 537), False, 'import json\n'), ((1167, 1183), 'json.dumps', 'json.dumps', (['meta'], {}), '(meta)\n', (1177, 1183),... |
import hashlib
import neptune.new as neptune
import pandas as pd
import xgboost as xgb
from neptune.new.integrations.xgboost import NeptuneCallback
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
# (neptune) create run
run = neptune.init(
project="<WORKSPACE/PR... | [
"neptune.new.init",
"neptune.new.integrations.xgboost.NeptuneCallback"
] | [((280, 371), 'neptune.new.init', 'neptune.init', ([], {'project': '"""<WORKSPACE/PROJECT>"""', 'name': '"""titanic-training"""', 'tags': "['XGBoost']"}), "(project='<WORKSPACE/PROJECT>', name='titanic-training', tags=[\n 'XGBoost'])\n", (292, 371), True, 'import neptune.new as neptune\n'), ((402, 426), 'pandas.read... |
#
# 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.exceptions.NeptuneException",
"neptune.get_experiment"
] | [((10228, 10301), 'xgboost.plot_importance', 'xgb.plot_importance', (['booster'], {'max_num_features': 'max_num_features'}), '(booster, max_num_features=max_num_features, **kwargs)\n', (10247, 10301), True, 'import xgboost as xgb\n'), ((10389, 10405), 'matplotlib.pyplot.close', 'plt.close', (['"""all"""'], {}), "('all'... |
import pickle
import gin
import neptune
import logging, os
import numpy as np
from keras.optimizers import Adam
from agents.greedy_agent_boost import GreedyAgentBoost
from agents.greedysearch_agent import GreedySearchAgent
from agents.minmax_agent import MinMaxAgent
from agents.random_agent import RandomAgent
from a... | [
"neptune.send_metric",
"neptune.stop",
"neptune.send_image"
] | [((849, 881), 'logging.disable', 'logging.disable', (['logging.WARNING'], {}), '(logging.WARNING)\n', (864, 881), False, 'import logging, os\n'), ((1409, 1468), 'neptune.send_metric', 'neptune.send_metric', (['"""epoch loss"""', 'self.epoch', "logs['loss']"], {}), "('epoch loss', self.epoch, logs['loss'])\n", (1428, 14... |
import neptune.new as neptune
import os
import matplotlib.pyplot as plt
token = os.getenv('Neptune_api')
run = neptune.init(
project="Deep-Learning-test/Deep-Learning-Test",
api_token=token,
run="DEEP-58"
) # 58
rate_58 = run['network/learning_rate'].fetch_values()
accuacy_58 = run['network/validation_acc... | [
"neptune.new.init"
] | [((81, 105), 'os.getenv', 'os.getenv', (['"""Neptune_api"""'], {}), "('Neptune_api')\n", (90, 105), False, 'import os\n'), ((112, 210), 'neptune.new.init', 'neptune.init', ([], {'project': '"""Deep-Learning-test/Deep-Learning-Test"""', 'api_token': 'token', 'run': '"""DEEP-58"""'}), "(project='Deep-Learning-test/Deep-L... |
# @Author: <NAME>
# @Date: Thu, July 2nd 2020, 3:39 am
# @Email: <EMAIL>
# @Filename: PNAS_train_pipeline.py
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from collections import OrderedDict
from stuf import stuf
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import r... | [
"neptune.log_text",
"neptune.init",
"neptune.append_tag",
"neptune.set_property",
"neptune.log_metric"
] | [((484, 535), 'tensorflow.config.experimental.list_physical_devices', 'tf.config.experimental.list_physical_devices', (['"""GPU"""'], {}), "('GPU')\n", (528, 535), True, 'import tensorflow as tf\n'), ((716, 731), 'random.seed', 'random.seed', (['(84)'], {}), '(84)\n', (727, 731), False, 'import random\n'), ((736, 754),... |
from pathlib import Path
from typing import Union
import neptune.new as neptune
def download_from_neptune(
project_name: str, experiment_name: str, neptune_file: str, out_path_or_file: Union[str, Path]
):
run = neptune.init(project_name, run=experiment_name)
run[neptune_file].download(str(out_path_or_fil... | [
"neptune.new.init"
] | [((222, 269), 'neptune.new.init', 'neptune.init', (['project_name'], {'run': 'experiment_name'}), '(project_name, run=experiment_name)\n', (234, 269), True, 'import neptune.new as neptune\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.types.File",
"neptune.new.types.File.from_content",
"neptune.new.internal.utils.base64_encode",
"neptune.new.attributes.series.file_series.FileSeries",
"neptune.new.internal.operation.ClearImageLog"
] | [((1118, 1164), 'mock.patch', 'patch', (['"""time.time"""'], {'new': 'TestAttributeBase._now'}), "('time.time', new=TestAttributeBase._now)\n", (1123, 1164), False, 'from mock import patch, MagicMock, call\n'), ((1801, 1812), 'mock.MagicMock', 'MagicMock', ([], {}), '()\n', (1810, 1812), False, 'from mock import patch,... |
#
# 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.runs_table.RunsTable",
"neptune.new.internal.utils.verify_collection_type"
] | [((5777, 5822), 'neptune.new.runs_table.RunsTable', 'RunsTable', (['self._backend', 'leaderboard_entries'], {}), '(self._backend, leaderboard_entries)\n', (5786, 5822), False, 'from neptune.new.runs_table import RunsTable\n'), ((6138, 6178), 'neptune.new.internal.utils.verify_collection_type', 'verify_collection_type',... |
#
# 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.backends.hosted_file_operations.download_file_attribute",
"neptune.new.internal.backends.hosted_file_operations.download_file_set_attribute",
"neptune.new.internal.backends.hosted_file_operations.upload_file_attribute",
"neptune.new.internal.backends.hosted_file_operations.upload_file_se... | [((1127, 1183), 'unittest.skipIf', 'unittest.skipIf', (['IS_WINDOWS', '"""Windows behaves strangely"""'], {}), "(IS_WINDOWS, 'Windows behaves strangely')\n", (1142, 1183), False, 'import unittest\n'), ((1189, 1263), 'mock.patch', 'patch', (['"""neptune.new.internal.backends.hosted_file_operations._upload_loop"""'], {})... |
#
# 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 applicable law or agreed to in w... | [
"neptune.internal.common.config.host_parser.HostParser",
"neptune.internal.common.config.host_parser.SecureParser",
"neptune.internal.common.config.host_parser.PortParser",
"neptune.internal.common.exceptions.keycloak_exceptions.KeycloakException",
"neptune.internal.common.api.address.http_url_from_address"... | [((1228, 1255), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1245, 1255), False, 'import logging\n'), ((2357, 2400), 'neptune.internal.common.api.tokens.CompositeToken.from_json', 'CompositeToken.from_json', ([], {'json_token': 'result'}), '(json_token=result)\n', (2381, 2400), False, ... |
#
# Copyright (c) 2018, 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.config.host_parser.HostParser",
"neptune.internal.common.config.host_parser.SecureParser",
"neptune.internal.common.config.host_parser.PortParser",
"neptune.internal.common.api.address.rest_url_from_address",
"neptune.internal.common.api.address.http_url_from_address",
"neptune.in... | [((856, 868), 'neptune.internal.common.config.host_parser.HostParser', 'HostParser', ([], {}), '()\n', (866, 868), False, 'from neptune.internal.common.config.host_parser import HostParser, PortParser, SecureParser\n'), ((887, 899), 'neptune.internal.common.config.host_parser.PortParser', 'PortParser', ([], {}), '()\n'... |
# Train shape recognition
from numpy import loadtxt
import os
import pandas as pd
from sklearn import metrics
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.svm import NuSVC... | [
"neptune.create_experiment",
"neptune.log_image",
"neptune.stop",
"neptune.log_metric"
] | [((1514, 1528), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1526, 1528), False, 'from datetime import datetime\n'), ((2610, 2705), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Demo for various training shape recognition methods"""'}), "(description=\n 'Demo for vario... |
#
# 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.internal.hardware.gauges.gpu.GpuMemoryGauge",
"neptune.internal.hardware.gauges.memory.SystemMemoryUsageGauge",
"neptune.internal.hardware.gauges.gpu.GpuUsageGauge",
"neptune.internal.hardware.gauges.cpu.SystemCpuUsageGauge",
"neptune.internal.hardware.gauges.gauge_factory.GaugeFactory",
"neptune... | [((5416, 5431), 'unittest.main', 'unittest.main', ([], {}), '()\n', (5429, 5431), False, 'import unittest\n'), ((1381, 1411), 'neptune.internal.hardware.gauges.gauge_factory.GaugeFactory', 'GaugeFactory', (['GaugeMode.SYSTEM'], {}), '(GaugeMode.SYSTEM)\n', (1393, 1411), False, 'from neptune.internal.hardware.gauges.gau... |
#
# 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.NeptuneInvalidApiTokenException",
"neptune.new.exceptions.NeptuneFeatureNotAvailableException",
"neptune.new.exceptions.NeptuneConnectionLostException",
"neptune.new.exceptions.SSLError",
"neptune.new.exceptions.Unauthorized",
"neptune.new.exceptions.ClientHttpError",
"neptune.ne... | [((2171, 2198), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (2188, 2198), False, 'import logging\n'), ((5141, 5176), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': 'None', 'typed': '(True)'}), '(maxsize=None, typed=True)\n', (5150, 5176), False, 'from functools import lru_cache, ... |
### This is inteded to be an easily modifiable VAE parent class for everyone who uses VAE-models
### Based on the pytorch lightning bolts VAE code
### neptune.AI support added (specifiy username and token in input var)
from argparse import ArgumentParser
import pytorch_lightning as pl
import torch
import torch.nn as ... | [
"neptune.init",
"neptune.log_metric"
] | [((687, 711), 'sys.path.append', 'sys.path.append', (['"""../.."""'], {}), "('../..')\n", (702, 711), False, 'import sys\n'), ((1628, 1662), 'systems.ecgresnet_uncertainty.ECGResNetUncertaintySystem', 'ECGResNetUncertaintySystem', ([], {}), '(**args)\n', (1654, 1662), False, 'from systems.ecgresnet_uncertainty import E... |
#
# 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.internal.hardware.gpu.gpu_monitor.GPUMonitor",
"neptune.internal.hardware.system.system_monitor.SystemMonitor"
] | [((1845, 1924), 'unittest.skipIf', 'unittest.skipIf', (['(IS_WINDOWS or IS_MACOS)', '"""Windows and MacOS don\'t have cgroups"""'], {}), '(IS_WINDOWS or IS_MACOS, "Windows and MacOS don\'t have cgroups")\n', (1860, 1924), False, 'import unittest\n'), ((6179, 6194), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6... |
# -*- 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.parsers.type_mapper.TypeMapper.to_bool"
] | [((883, 908), 'neptune.internal.common.parsers.type_mapper.TypeMapper.to_bool', 'TypeMapper.to_bool', (['value'], {}), '(value)\n', (901, 908), False, 'from neptune.internal.common.parsers.type_mapper import TypeMapper\n')] |
# -*- 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.generated.swagger_client.models.EditExperimentParams",
"neptune.internal.common.models.parameters_validation.validate"
] | [((2360, 2383), 'neptune.internal.common.models.parameters_validation.validate', 'validate', ([], {'item': 'int_conv'}), '(item=int_conv)\n', (2368, 2383), False, 'from neptune.internal.common.models.parameters_validation import int_conv, text_conv, text_conv_coll, validate\n'), ((2494, 2533), 'neptune.internal.common.... |
#
# 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.exceptions.NotAFile",
"neptune.api_exceptions.ConnectionLost",
"neptune.api_exceptions.ServerError",
"neptune.api_exceptions.SSLError",
"neptune.exceptions.InvalidNotebookPath",
"neptune.api_exceptions.Forbidden",
"neptune.exceptions.FileNotFound",
"neptune.api_exceptions.Unauthorized"
] | [((1216, 1243), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1233, 1243), False, 'import logging\n'), ((1731, 1756), 'neptune.exceptions.InvalidNotebookPath', 'InvalidNotebookPath', (['path'], {}), '(path)\n', (1750, 1756), False, 'from neptune.exceptions import InvalidNotebookPath, Fi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.