id int64 1 6.07M | name stringlengths 1 295 | code stringlengths 12 426k | language stringclasses 1
value | source_file stringlengths 5 202 | start_line int64 1 158k | end_line int64 1 158k | repo dict |
|---|---|---|---|---|---|---|---|
2,001 | __init__ | def __init__(self, k, *args, **kwargs):
super().__init__(*args, **kwargs)
self.k = k | python | wandb/apis/reports/validators.py | 84 | 86 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,002 | call | def call(self, attr_name, value):
if len(value) != self.k:
raise ValueError(
f"{attr_name} must have exactly {self.k} elements (got {len(value)!r}, elems: {value!r})"
) | python | wandb/apis/reports/validators.py | 88 | 92 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,003 | __init__ | def __init__(self, lb, ub, *args, **kwargs):
super().__init__(*args, **kwargs)
self.lb = lb
self.ub = ub | python | wandb/apis/reports/validators.py | 96 | 99 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,004 | call | def call(self, attr_name, value):
if not self.lb <= value <= self.ub:
raise ValueError(
f"{attr_name} must be between [{self.lb}, {self.ub}] inclusive (got {value})"
) | python | wandb/apis/reports/validators.py | 101 | 105 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,005 | __init__ | def __init__(self):
super().__init__(attr_type=str) | python | wandb/apis/reports/validators.py | 109 | 110 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,006 | call | def call(self, attr_name, value):
super().call(attr_name, value)
if value[0] not in {"+", "-"}:
raise ValueError(
f'{attr_name} must be prefixed with "+" or "-" to indicate ascending or descending order'
) | python | wandb/apis/reports/validators.py | 112 | 118 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,007 | call | def call(self, attr_name, value):
if set(value.keys()) != {"x", "y", "w", "h"}:
raise ValueError(
f"{attr_name} must be a dict containing exactly the keys `x`, y`, `w`, `h`"
)
for k, v in value.items():
if not isinstance(v, int):
raise ValueError(
f"{attr_name} key `{k}` must be of type {int} (got {type(v)!r})"
) | python | wandb/apis/reports/validators.py | 122 | 131 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,008 | __init__ | def __init__(
self,
entity=None,
project=None,
name="Run set",
query="",
filters=None,
groupby=None,
order=None,
*args,
**kwargs,
):
super().__init__(*args, **kwargs)
self._spec = self._default_runset_spec()
self.query_generator = QueryGenerator()
self.pm_query_generator = PythonMongoishQueryGenerator(self)
self.entity = coalesce(entity, PublicApi().default_entity, "")
self.project = project # If the project is None, it will be updated to the report's project on save. See: Report.save
self.name = name
self.query = query
self.filters = coalesce(filters, self._default_filters())
self.groupby = coalesce(groupby, self._default_groupby())
self.order = coalesce(order, self._default_order()) | python | wandb/apis/reports/runset.py | 19 | 42 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,009 | from_json | def from_json(cls, spec: Dict[str, Any]) -> T:
"""This has a custom implementation because sometimes runsets are missing the project field."""
obj = cls()
obj._spec = spec
project = spec.get("project")
if project:
obj.entity = project.get(
"entityName", coalesce(PublicApi().default_entity, "")
)
obj.project = project.get("name")
else:
obj.entity = coalesce(PublicApi().default_entity, "")
obj.project = None
return obj | python | wandb/apis/reports/runset.py | 45 | 60 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,010 | filters | def filters(self):
json_path = self._get_path("filters")
filter_specs = nested_get(self, json_path)
return self.query_generator.filter_to_mongo(filter_specs) | python | wandb/apis/reports/runset.py | 63 | 66 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,011 | filters | def filters(self, new_filters):
json_path = self._get_path("filters")
new_filter_specs = self.query_generator.mongo_to_filter(new_filters)
nested_set(self, json_path, new_filter_specs) | python | wandb/apis/reports/runset.py | 69 | 72 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,012 | set_filters_with_python_expr | def set_filters_with_python_expr(self, expr):
self.filters = self.pm_query_generator.python_to_mongo(expr)
return self | python | wandb/apis/reports/runset.py | 74 | 76 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,013 | groupby | def groupby(self):
json_path = self._get_path("groupby")
groupby_specs = nested_get(self, json_path)
cols = [self.query_generator.key_to_server_path(k) for k in groupby_specs]
return [self.pm_query_generator.back_to_front(c) for c in cols] | python | wandb/apis/reports/runset.py | 79 | 83 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,014 | groupby | def groupby(self, new_groupby):
json_path = self._get_path("groupby")
cols = [self.pm_query_generator.front_to_back(g) for g in new_groupby]
new_groupby_specs = [self.query_generator.server_path_to_key(c) for c in cols]
nested_set(self, json_path, new_groupby_specs) | python | wandb/apis/reports/runset.py | 86 | 90 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,015 | order | def order(self):
json_path = self._get_path("order")
order_specs = nested_get(self, json_path)
cols = self.query_generator.keys_to_order(order_specs)
return [c[0] + self.pm_query_generator.back_to_front(c[1:]) for c in cols] | python | wandb/apis/reports/runset.py | 93 | 97 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,016 | order | def order(self, new_orders):
json_path = self._get_path("order")
cols = [o[0] + self.pm_query_generator.front_to_back(o[1:]) for o in new_orders]
new_order_specs = self.query_generator.order_to_keys(cols)
nested_set(self, json_path, new_order_specs) | python | wandb/apis/reports/runset.py | 100 | 104 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,017 | _runs_config | def _runs_config(self) -> dict:
return {k: v for run in self.runs for k, v in run.config.items()} | python | wandb/apis/reports/runset.py | 107 | 108 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,018 | runs | def runs(self) -> Runs:
return PublicApi().runs(
path=f"{self.entity}/{self.project}", filters=self.filters
) | python | wandb/apis/reports/runset.py | 111 | 114 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,019 | _default_filters | def _default_filters():
return {"$or": [{"$and": []}]} | python | wandb/apis/reports/runset.py | 117 | 118 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,020 | _default_groupby | def _default_groupby():
return [] | python | wandb/apis/reports/runset.py | 121 | 122 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,021 | _default_order | def _default_order():
return ["-CreatedTimestamp"] | python | wandb/apis/reports/runset.py | 125 | 126 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,022 | _default_runset_spec | def _default_runset_spec():
return {
"id": generate_name(),
"runFeed": {
"version": 2,
"columnVisible": {"run:name": False},
"columnPinned": {},
"columnWidths": {},
"columnOrder": [],
"pageSize": 10,
"onlyShowSelected": False,
},
"enabled": True,
"selections": {"root": 1, "bounds": [], "tree": []},
"expandedRowAddresses": [],
} | python | wandb/apis/reports/runset.py | 129 | 144 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,023 | create_example_header | def create_example_header():
"""Create an example header with image at top."""
import wandb.apis.reports as wr
return [
wr.P(),
wr.HorizontalRule(),
wr.P(),
wr.Image(
"https://camo.githubusercontent.com/83839f20c90facc062330f8fee5a7ab910fdd04b80b4c4c7e89d6d8137543540/68747470733a2f2f692e696d6775722e636f6d2f676236423469672e706e67"
),
wr.P(),
wr.HorizontalRule(),
wr.P(),
] | python | wandb/apis/reports/_templates.py | 6 | 20 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,024 | create_example_footer | def create_example_footer():
"""Create an example footer with image and text at bottom."""
import wandb.apis.reports as wr
return [
wr.P(),
wr.HorizontalRule(),
wr.P(),
wr.H1("Disclaimer"),
wr.P(
"The views and opinions expressed in this report are those of the authors and do not necessarily reflect the official policy or position of Weights & Biases. blah blah blah blah blah boring text at the bottom"
),
wr.P(),
wr.HorizontalRule(),
] | python | wandb/apis/reports/_templates.py | 23 | 37 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,025 | create_enterprise_report | def create_enterprise_report(
project=None,
title="Untitled Report",
description="",
header=None,
body=None,
footer=None,
):
"""Create an example enterprise report with a header and footer.
Can be used to add custom branding to reports.
"""
import wandb.apis.reports as wr
project = coalesce(project, "default-project")
header = coalesce(header, create_example_header())
body = coalesce(body, [])
footer = coalesce(footer, create_example_footer())
return wr.Report(
project=project,
title=title,
description=description,
blocks=[*header, *body, *footer],
) | python | wandb/apis/reports/_templates.py | 40 | 64 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,026 | create_customer_landing_page | def create_customer_landing_page(
project=None,
company_name="My Company",
main_contact="My Contact (name@email.com)",
slack_link="https://company.slack.com",
):
"""Create an example customer landing page using data from Andrew's demo."""
import wandb.apis.reports as wr
project = coalesce(project, "default-project")
return wr.Report(
project,
title=f"Weights & Biases @ {company_name}",
description=f"The developer-first MLOps platform is now available at {company_name}!\nReach out to {main_contact} for an account, and join your dedicated slack channel at:\n{slack_link}",
blocks=[
wr.P(),
wr.HorizontalRule(),
wr.TableOfContents(),
wr.P(),
wr.HorizontalRule(),
wr.H1(text=["What is Weights & Biases?"]),
wr.P(
text=[
"Weights & Biases (W&B) is the developer-first MLOps platform to build better models faster. Over 200,000+ ML practitioners at 500+ companies use W&B to optimize their ML workflows in Natural Language, Computer Vision, Reinforcement Learning, Tabular ML, Finance, and more!"
]
),
wr.P(),
wr.H2(text=["Why do you need W&B?"]),
wr.P(
text=[
"ML is a highly experimental field. Often we try many different datasets, model architectures, optimizers, hyperparameters, etc."
]
),
wr.P(
text=["Experimentation is great, but it can get messy. Have you ever:"]
),
wr.UnorderedList(
items=[
["Logged experiments in a sketchy spreadsheet?"],
[
"Built an amazing model but could not reproduce it for a colleague / model validation?"
],
["Wondered why your model is making strange predictions?"],
["Fumbled with tuning hyperparameters?"],
[
"Struggled explaining to a colleague the impact of what you're doing?"
],
]
),
wr.P(
text=["If that sounds familiar, W&B might be a good solution for you!"]
),
wr.P(),
wr.H2(
text=[
"What does W&B do?",
wr.Link(text="", url="https://wandb.ai/site/experiment-tracking"),
]
),
wr.P(
text=[
wr.Link(text="", url="https://wandb.ai/site/experiment-tracking"),
"W&B has lightweight and flexible tools for... (expand to see more)",
]
),
wr.H3(
text=[
wr.Link(
text="Experiment tracking",
url="https://wandb.ai/site/experiment-tracking",
)
]
),
wr.PanelGrid(
runsets=[
wr.Runset(
entity="megatruong",
project="whirlwind_test4",
name="Run set",
query="",
filters={
"$or": [
{
"$and": [
{"state": {"$ne": "crashed"}},
{
"config.Learner.value.opt_func": {
"$ne": None
}
},
]
}
]
},
groupby=["Learner.opt_func"],
order=["-CreatedTimestamp"],
)
],
panels=[
wr.LinePlot(
x="Step",
y=["gradients/layers.0.4.0.bn1.bias"],
log_y=False,
groupby="None",
layout={"x": 16, "y": 12, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["gradients/layers.0.1.weight"],
log_y=False,
groupby="None",
layout={"x": 8, "y": 12, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["gradients/layers.0.1.bias"],
log_y=False,
groupby="None",
layout={"x": 0, "y": 12, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["train_loss"],
log_y=False,
groupby="None",
layout={"x": 16, "y": 0, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["valid_loss"],
log_y=False,
groupby="None",
layout={"x": 16, "y": 6, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["top_k_accuracy"],
log_y=False,
groupby="None",
layout={"x": 8, "y": 0, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["mom_0"],
log_y=False,
groupby="None",
layout={"x": 0, "y": 6, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["lr_0"],
log_y=False,
groupby="None",
layout={"x": 8, "y": 6, "w": 8, "h": 6},
),
wr.LinePlot(
x="Step",
y=["accuracy"],
log_y=False,
groupby="None",
layout={"x": 0, "y": 0, "w": 8, "h": 6},
),
],
custom_run_colors={
("Run set", "megatruong"): "rgb(83, 135, 221)",
("Run set", "fastai.optimizer.ranger"): "rgb(83, 135, 221)",
("Run set", "fastai.optimizer.Adam"): "rgb(229, 116, 57)",
},
),
wr.P(
text=[
wr.Link(
text="",
url="https://assets.website-files.com/5ac6b7f2924c656f2b13a88c/6066c22135b8983b61ad7939_weights-and-biases-logo.svg",
)
]
),
wr.H3(
text=[
wr.Link(
text="Dataset and model versioning, evaluation, and reproduction",
url="https://wandb.ai/site/artifacts",
)
]
),
wr.WeaveBlockArtifact(
entity="megatruong",
project="whirlwind_test4",
artifact="camvid_learner",
tab="lineage",
),
wr.P(),
wr.H3(
text=[
wr.Link(
text="Hyperparameter optimization",
url="https://wandb.ai/site/sweeps",
)
]
),
wr.P(text=[wr.Link(text="", url="https://wandb.ai/site/sweeps")]),
wr.PanelGrid(
runsets=[
wr.Runset(
entity="wandb",
project="cartpole",
name="Run set",
query="sweep",
filters={"$or": [{"$and": []}]},
order=["-CreatedTimestamp"],
)
],
panels=[
wr.MediaBrowser(layout={"x": 0, "y": 10, "w": 24, "h": 10}),
wr.ParallelCoordinatesPlot(
columns=[
wr.PCColumn(metric="c::activation"),
wr.PCColumn(metric="c::lr", log_scale=True),
wr.PCColumn(
metric="c::target_model_update",
log_scale=True,
),
wr.PCColumn(metric="c::n_hidden", log_scale=True),
wr.PCColumn(metric="test_reward"),
],
layout={"x": 0, "y": 0, "w": 24, "h": 10},
),
],
),
wr.H3(
text=[
wr.Link(
text="Model visualization and analysis",
url="https://wandb.ai/site/tables",
)
]
),
wr.P(text=[wr.Link(text="", url="https://wandb.ai/site/tables")]),
wr.PanelGrid(
runsets=[
wr.Runset(
entity="megatruong",
project="whirlwind_test4",
name="Run set",
query="",
filters={"$or": [{"$and": []}]},
order=["-CreatedTimestamp"],
)
],
panels=[
wr.WeavePanelSummaryTable(
table_name="valid_table",
layout={"x": 7, "y": 0, "w": 7, "h": 13},
),
wr.WeavePanelSummaryTable(
table_name="img_table",
layout={"x": 0, "y": 0, "w": 7, "h": 13},
),
wr.WeavePanelSummaryTable(
table_name="image_table",
layout={"x": 14, "y": 0, "w": 10, "h": 13},
),
],
),
wr.P(),
wr.PanelGrid(
runsets=[
wr.Runset(
entity="wandb",
project="wandb_spacy_integration",
name="Run set",
query="",
filters={"$or": [{"$and": []}]},
order=["-CreatedTimestamp"],
)
],
panels=[
wr.WeavePanelSummaryTable(
table_name="spaCy NER table",
layout={"x": 0, "y": 0, "w": 24, "h": 10},
),
wr.WeavePanelSummaryTable(
table_name="per annotation scores",
layout={"x": 7, "y": 10, "w": 17, "h": 8},
),
wr.WeavePanelSummaryTable(
table_name="metrics", layout={"x": 0, "y": 10, "w": 7, "h": 8}
),
],
),
wr.H3(
text=[
wr.Link(
text="ML team collaboration and sharing results",
url="https://wandb.ai/site/reports",
)
]
),
wr.H2(text=["How do I get access?"]),
wr.P(text=[f"Ask {main_contact} to help:"]),
wr.OrderedList(
items=[
["Set up your account"],
[
"Get added to the ",
wr.Link(
text="joint slack channel",
url=slack_link,
),
],
]
),
wr.HorizontalRule(),
wr.H1(text=["Getting Started"]),
wr.P(text=["W&B has two components:"]),
wr.OrderedList(
items=[
["A centrally managed MLOps platform and UI"],
[
"The ",
wr.InlineCode(code="wandb"),
" SDK (",
wr.Link(text="github", url="https://github.com/wandb/client"),
", ",
wr.Link(text="pypi", url="https://pypi.org/project/wandb/"),
", ",
wr.Link(
text="conda-forge",
url="https://anaconda.org/conda-forge/wandb",
),
")",
],
]
),
wr.P(),
wr.H3(text=["1. Install the SDK"]),
wr.CodeBlock(code=["pip install wandb"], language="python"),
wr.P(),
wr.H3(text=["2. Log in to W&B"]),
wr.P(text=["You will be prompted to get and set your API key in the UI."]),
wr.CodeBlock(code=["wandb.login()"], language="python"),
wr.P(),
wr.H3(text=["3. Setup an experiment"]),
wr.P(
text=[
"Add this to the beginning of your scripts (or top of your notebook)."
]
),
wr.CodeBlock(code=["wandb.init()"], language="python"),
wr.P(),
wr.P(
text=[
wr.Link(
text="For more details on options and advanced usage, see the docs.",
url="https://docs.wandb.ai/ref/python/init",
)
]
),
wr.P(),
wr.H3(text=["4. Log anything!"]),
wr.P(text=["You can log metrics anywhere in your script, for example"]),
wr.CodeBlock(code=['wandb.log({"loss": model_loss})'], language="python"),
wr.P(),
wr.P(
text=[
"Log metrics, graphs, dataframes, images with segmentation masks or bounding boxes, videos, point clouds, custom HTML, and more! ",
wr.Link(
text="For more details on logging, including advanced types, see the docs.",
url="https://docs.wandb.ai/guides/track/log",
),
]
),
wr.P(text=["W&B also helps you reproduce results by capturing:"]),
wr.UnorderedList(
items=[
["git state (repo, commit)"],
["requirements (requirements.txt, conda_env.yml)"],
["logs, including stdout"],
[
"hardware metrics (CPU, GPU, network, memory utilization, temperature, throughput)"
],
["and more!"],
]
),
wr.P(),
wr.H3(text=["Putting everything together:"]),
wr.CodeBlock(
code=[
"wandb.login()",
"",
"wandb.init()",
"for i in range(1000):",
' wandb.log({"metric": i})',
],
language="python",
),
wr.P(),
wr.H1(text=["What else is possible with W&B?"]),
wr.H2(text=["Example projects"]),
wr.Gallery(
ids=[
"Vmlldzo4ODc0MDc=",
"Vmlldzo4NDI3NzM=",
"Vmlldzo2MDIzMTg=",
"VmlldzoyMjA3MjY=",
"Vmlldzo1NjM4OA==",
]
),
wr.P(),
],
) | python | wandb/apis/reports/_templates.py | 67 | 478 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,027 | __init__ | def __init__(
self,
project,
entity=None,
title="Untitled Report",
description="",
width="readable",
blocks=None,
*args,
**kwargs,
):
super().__init__(*args, **kwargs)
self._viewspec = self._default_viewspec()
self._orig_viewspec = deepcopy(self._viewspec)
self.project = project
self.entity = coalesce(entity, PublicApi().default_entity, "")
self.title = title
self.description = description
self.width = width
self.blocks = coalesce(blocks, []) | python | wandb/apis/reports/report.py | 34 | 54 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,028 | from_url | def from_url(cls, url):
report_id = cls._url_to_report_id(url)
r = PublicApi().client.execute(
VIEW_REPORT, variable_values={"reportId": report_id}
)
viewspec = r["view"]
viewspec["spec"] = json.loads(viewspec["spec"])
return cls.from_json(viewspec) | python | wandb/apis/reports/report.py | 57 | 64 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,029 | _url_to_report_id | def _url_to_report_id(url):
try:
report, *_ = url.split("?")
# If the report title ends in trailing space
report = report.replace("---", "--")
*_, report_id = report.split("--")
except ValueError as e:
raise ValueError("Path must be `entity/project/reports/report_id`") from e
else:
return report_id | python | wandb/apis/reports/report.py | 67 | 76 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,030 | blocks | def blocks(self):
json_path = self._get_path("blocks")
block_specs = nested_get(self, json_path)
blocks = []
for bspec in block_specs:
cls = block_mapping.get(bspec["type"], UnknownBlock)
if cls is UnknownBlock:
termwarn(
inspect.cleandoc(
f"""
UNKNOWN BLOCK DETECTED
This can happen if we have added new blocks, but you are using an older version of the SDK.
If your report is loading normally, you can safely ignore this message (but we recommend not touching UnknownBlock)
If you think this is an error, please file a bug report including your SDK version ({wandb_ver}) and this spec ({bspec})
"""
)
)
if cls is WeaveBlock:
for cls in weave_blocks:
try:
cls.from_json(bspec)
except Exception:
pass
else:
break
blocks.append(cls.from_json(bspec))
return blocks[1:-1] # accounts for hidden p blocks | python | wandb/apis/reports/report.py | 79 | 105 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,031 | blocks | def blocks(self, new_blocks):
json_path = self._get_path("blocks")
new_block_specs = (
[P("").spec] + [b.spec for b in new_blocks] + [P("").spec]
) # hidden p blocks
nested_set(self, json_path, new_block_specs) | python | wandb/apis/reports/report.py | 108 | 113 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,032 | _default_viewspec | def _default_viewspec():
return {
"id": None,
"name": None,
"spec": {
"version": 5,
"panelSettings": {},
"blocks": [],
"width": "readable",
"authors": [],
"discussionThreads": [],
"ref": {},
},
} | python | wandb/apis/reports/report.py | 116 | 129 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,033 | from_json | def from_json(cls, viewspec):
obj = cls(project=viewspec["project"]["name"])
obj._viewspec = viewspec
obj._orig_viewspec = deepcopy(obj._viewspec)
return obj | python | wandb/apis/reports/report.py | 132 | 136 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,034 | viewspec | def viewspec(self):
return self._viewspec | python | wandb/apis/reports/report.py | 139 | 140 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,035 | modified | def modified(self) -> bool:
return self._viewspec != self._orig_viewspec | python | wandb/apis/reports/report.py | 143 | 144 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,036 | spec | def spec(self) -> dict:
return self._viewspec["spec"] | python | wandb/apis/reports/report.py | 147 | 148 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,037 | client | def client(self) -> "RetryingClient":
return PublicApi().client | python | wandb/apis/reports/report.py | 151 | 152 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,038 | id | def id(self) -> str:
return self._viewspec["id"] | python | wandb/apis/reports/report.py | 155 | 156 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,039 | name | def name(self) -> str:
return self._viewspec["name"] | python | wandb/apis/reports/report.py | 159 | 160 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,040 | panel_grids | def panel_grids(self) -> "LList[PanelGrid]":
return [b for b in self.blocks if isinstance(b, PanelGrid)] | python | wandb/apis/reports/report.py | 163 | 164 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,041 | runsets | def runsets(self) -> "LList[Runset]":
return [rs for pg in self.panel_grids for rs in pg.runsets] | python | wandb/apis/reports/report.py | 167 | 168 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,042 | url | def url(self) -> str:
title = re.sub(r"\W", "-", self.title)
title = re.sub(r"-+", "-", title)
title = urllib.parse.quote(title)
id = self.id.replace("=", "")
app_url = PublicApi().client.app_url
if not app_url.endswith("/"):
app_url = app_url + "/"
return f"{app_url}{self.entity}/{self.project}/reports/{title}--{id}" | python | wandb/apis/reports/report.py | 171 | 179 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,043 | save | def save(self, draft: bool = False, clone: bool = False) -> "Report":
if not self.modified:
termwarn("Report has not been modified")
# create project if not exists
PublicApi().create_project(self.project, self.entity)
# All panel grids must have at least one runset
for pg in self.panel_grids:
if not pg.runsets:
pg.runsets = PanelGrid._default_runsets()
# Check runsets with `None` for project and replace with the report's project.
# We have to do this here because RunSets don't know about their report until they're added to it.
for rs in self.runsets:
rs.entity = coalesce(rs.entity, PublicApi().default_entity)
rs.project = coalesce(rs.project, self.project)
r = PublicApi().client.execute(
UPSERT_VIEW,
variable_values={
"id": None if clone or not self.id else self.id,
"name": generate_name() if clone or not self.name else self.name,
"entityName": self.entity,
"projectName": self.project,
"description": self.description,
"displayName": self.title,
"type": "runs/draft" if draft else "runs",
"spec": json.dumps(self.spec),
},
)
viewspec = r["upsertView"]["view"]
viewspec["spec"] = json.loads(viewspec["spec"])
if clone:
return Report.from_json(viewspec)
else:
self._viewspec["id"] = viewspec["id"]
self._viewspec["name"] = viewspec["name"]
return self | python | wandb/apis/reports/report.py | 181 | 220 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,044 | to_html | def to_html(self, height: int = 1024, hidden: bool = False) -> str:
"""Generate HTML containing an iframe displaying this report."""
try:
url = self.url + "?jupyter=true"
style = f"border:none;width:100%;height:{height}px;"
prefix = ""
if hidden:
style += "display:none;"
prefix = ipython.toggle_button("report")
return prefix + f"<iframe src={url!r} style={style!r}></iframe>"
except AttributeError:
termlog("HTML repr will be available after you save the report!") | python | wandb/apis/reports/report.py | 222 | 233 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,045 | _repr_html_ | def _repr_html_(self) -> str:
return self.to_html() | python | wandb/apis/reports/report.py | 235 | 236 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,046 | __init__ | def __init__(self, key: str) -> None:
self.key = key | python | wandb/apis/reports/_helpers.py | 9 | 10 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,047 | __hash__ | def __hash__(self) -> int:
return hash(self.key) | python | wandb/apis/reports/_helpers.py | 12 | 13 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,048 | __repr__ | def __repr__(self) -> str:
return f"LineKey(key={self.key!r})" | python | wandb/apis/reports/_helpers.py | 15 | 16 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,049 | from_run | def from_run(cls, run: "Run", metric: str) -> "LineKey":
key = f"{run.id}:{metric}"
return cls(key) | python | wandb/apis/reports/_helpers.py | 19 | 21 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,050 | from_panel_agg | def from_panel_agg(cls, runset: "Runset", panel: "Panel", metric: str) -> "LineKey":
key = f"{runset.id}-config:group:{panel.groupby}:null:{metric}"
return cls(key) | python | wandb/apis/reports/_helpers.py | 24 | 26 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,051 | from_runset_agg | def from_runset_agg(cls, runset: "Runset", metric: str) -> "LineKey":
groupby = runset.groupby
if runset.groupby is None:
groupby = "null"
key = f"{runset.id}-run:group:{groupby}:{metric}"
return cls(key) | python | wandb/apis/reports/_helpers.py | 29 | 35 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,052 | __init__ | def __init__(
self, metric, name=None, ascending=None, log_scale=None, *args, **kwargs
):
super().__init__(*args, **kwargs)
self.panel_metrics_helper = PanelMetricsHelper()
self.metric = metric
self.name = name
self.ascending = ascending
self.log_scale = log_scale | python | wandb/apis/reports/_helpers.py | 44 | 52 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,053 | from_json | def from_json(cls, spec):
obj = cls(metric=spec["accessor"])
obj._spec = spec
return obj | python | wandb/apis/reports/_helpers.py | 55 | 58 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,054 | metric | def metric(self):
json_path = self._get_path("metric")
value = nested_get(self, json_path)
return self.panel_metrics_helper.special_back_to_front(value) | python | wandb/apis/reports/_helpers.py | 61 | 64 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,055 | metric | def metric(self, value):
json_path = self._get_path("metric")
value = self.panel_metrics_helper.special_front_to_back(value)
nested_set(self, json_path, value) | python | wandb/apis/reports/_helpers.py | 67 | 70 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,056 | histogram | def histogram(table: wandb.Table, value: str, title: Optional[str] = None):
"""Construct a histogram plot.
Arguments:
table (wandb.Table): Table of data.
value (string): Name of column to use as data for bucketing.
title (string): Plot title.
Returns:
A plot object, to be passed to wandb.log()
Example:
```
data = [[i, random.random() + math.sin(i / 10)] for i in range(100)]
table = wandb.Table(data=data, columns=["step", "height"])
wandb.log({'histogram-plot1': wandb.plot.histogram(table, "height")})
```
"""
return wandb.plot_table(
"wandb/histogram/v0", table, {"value": value}, {"title": title}
) | python | wandb/plot/histogram.py | 6 | 26 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,057 | line | def line(
table: wandb.Table,
x: str,
y: str,
stroke: Optional[str] = None,
title: Optional[str] = None,
):
"""Construct a line plot.
Arguments:
table (wandb.Table): Table of data.
x (string): Name of column to as for x-axis values.
y (string): Name of column to as for y-axis values.
stroke (string): Name of column to map to the line stroke scale.
title (string): Plot title.
Returns:
A plot object, to be passed to wandb.log()
Example:
```
data = [[i, random.random() + math.sin(i / 10)] for i in range(100)]
table = wandb.Table(data=data, columns=["step", "height"])
wandb.log({'line-plot1': wandb.plot.line(table, "step", "height")})
```
"""
return wandb.plot_table(
"wandb/line/v0", table, {"x": x, "y": y, "stroke": stroke}, {"title": title}
) | python | wandb/plot/line.py | 6 | 34 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,058 | pr_curve | def pr_curve(
y_true=None,
y_probas=None,
labels=None,
classes_to_plot=None,
interp_size=21,
title=None,
):
"""Compute the tradeoff between precision and recall for different thresholds.
A high area under the curve represents both high recall and high precision, where
high precision relates to a low false positive rate, and high recall relates to a
low false negative rate. High scores for both show that the classifier is returning
accurate results (high precision), and returning a majority of all positive results
(high recall). PR curve is useful when the classes are very imbalanced.
Arguments:
y_true (arr): true sparse labels y_probas (arr): Target scores, can either be
probability estimates, confidence values, or non-thresholded measure of
decisions. shape: (*y_true.shape, num_classes)
labels (list): Named labels for target variable (y). Makes plots easier to read
by replacing target values with corresponding index. For example labels =
['dog', 'cat', 'owl'] all 0s are replaced by 'dog', 1s by 'cat'.
classes_to_plot (list): unique values of y_true to include in the plot
interp_size (int): the recall values will be fixed to `interp_size` points
uniform on [0, 1] and the precision will be interpolated for these recall
values.
Returns:
Nothing. To see plots, go to your W&B run page then expand the 'media' tab under
'auto visualizations'.
Example:
```
wandb.log({"pr-curve": wandb.plot.pr_curve(y_true, y_probas, labels)})
```
"""
np = util.get_module(
"numpy",
required="roc requires the numpy library, install with `pip install numpy`",
)
pd = util.get_module(
"pandas",
required="roc requires the pandas library, install with `pip install pandas`",
)
sklearn_metrics = util.get_module(
"sklearn.metrics",
"roc requires the scikit library, install with `pip install scikit-learn`",
)
sklearn_utils = util.get_module(
"sklearn.utils",
"roc requires the scikit library, install with `pip install scikit-learn`",
)
def _step(x):
y = np.array(x)
for i in range(1, len(y)):
y[i] = max(y[i], y[i - 1])
return y
y_true = np.array(y_true)
y_probas = np.array(y_probas)
if not test_missing(y_true=y_true, y_probas=y_probas):
return
if not test_types(y_true=y_true, y_probas=y_probas):
return
classes = np.unique(y_true)
if classes_to_plot is None:
classes_to_plot = classes
precision = dict()
interp_recall = np.linspace(0, 1, interp_size)[::-1]
indices_to_plot = np.where(np.isin(classes, classes_to_plot))[0]
for i in indices_to_plot:
if labels is not None and (
isinstance(classes[i], int) or isinstance(classes[0], np.integer)
):
class_label = labels[classes[i]]
else:
class_label = classes[i]
cur_precision, cur_recall, _ = sklearn_metrics.precision_recall_curve(
y_true, y_probas[:, i], pos_label=classes[i]
)
# smooth the precision (monotonically increasing)
cur_precision = _step(cur_precision)
# reverse order so that recall in ascending
cur_precision = cur_precision[::-1]
cur_recall = cur_recall[::-1]
indices = np.searchsorted(cur_recall, interp_recall, side="left")
precision[class_label] = cur_precision[indices]
df = pd.DataFrame(
{
"class": np.hstack([[k] * len(v) for k, v in precision.items()]),
"precision": np.hstack(list(precision.values())),
"recall": np.tile(interp_recall, len(precision)),
}
)
df = df.round(3)
if len(df) > wandb.Table.MAX_ROWS:
wandb.termwarn(
"wandb uses only %d data points to create the plots." % wandb.Table.MAX_ROWS
)
# different sampling could be applied, possibly to ensure endpoints are kept
df = sklearn_utils.resample(
df,
replace=False,
n_samples=wandb.Table.MAX_ROWS,
random_state=42,
stratify=df["class"],
).sort_values(["precision", "recall", "class"])
table = wandb.Table(dataframe=df)
title = title or "Precision v. Recall"
return wandb.plot_table(
"wandb/area-under-curve/v0",
table,
{"x": "recall", "y": "precision", "class": "class"},
{"title": title},
) | python | wandb/plot/pr_curve.py | 6 | 130 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,059 | _step | def _step(x):
y = np.array(x)
for i in range(1, len(y)):
y[i] = max(y[i], y[i - 1])
return y | python | wandb/plot/pr_curve.py | 60 | 64 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,060 | roc_curve | def roc_curve(
y_true=None, y_probas=None, labels=None, classes_to_plot=None, title=None
):
"""Calculate and visualize receiver operating characteristic (ROC) scores.
Arguments:
y_true (arr): true sparse labels
y_probas (arr): Target scores, can either be probability estimates, confidence
values, or non-thresholded measure of decisions.
shape: (*y_true.shape, num_classes)
labels (list): Named labels for target variable (y). Makes plots easier to
read by replacing target values with corresponding index.
For example labels = ['dog', 'cat', 'owl'] all 0s are
replaced by 'dog', 1s by 'cat'.
classes_to_plot (list): unique values of y_true to include in the plot
Returns:
Nothing. To see plots, go to your W&B run page then expand the 'media' tab
under 'auto visualizations'.
Example:
```
wandb.log({'roc-curve': wandb.plot.roc_curve(y_true, y_probas, labels)})
```
"""
np = util.get_module(
"numpy",
required="roc requires the numpy library, install with `pip install numpy`",
)
pd = util.get_module(
"pandas",
required="roc requires the pandas library, install with `pip install pandas`",
)
sklearn_metrics = util.get_module(
"sklearn.metrics",
"roc requires the scikit library, install with `pip install scikit-learn`",
)
sklearn_utils = util.get_module(
"sklearn.utils",
"roc requires the scikit library, install with `pip install scikit-learn`",
)
y_true = np.array(y_true)
y_probas = np.array(y_probas)
if not test_missing(y_true=y_true, y_probas=y_probas):
return
if not test_types(y_true=y_true, y_probas=y_probas):
return
classes = np.unique(y_true)
if classes_to_plot is None:
classes_to_plot = classes
fpr = dict()
tpr = dict()
indices_to_plot = np.where(np.isin(classes, classes_to_plot))[0]
for i in indices_to_plot:
if labels is not None and (
isinstance(classes[i], int) or isinstance(classes[0], np.integer)
):
class_label = labels[classes[i]]
else:
class_label = classes[i]
fpr[class_label], tpr[class_label], _ = sklearn_metrics.roc_curve(
y_true, y_probas[..., i], pos_label=classes[i]
)
df = pd.DataFrame(
{
"class": np.hstack([[k] * len(v) for k, v in fpr.items()]),
"fpr": np.hstack(list(fpr.values())),
"tpr": np.hstack(list(tpr.values())),
}
)
df = df.round(3)
if len(df) > wandb.Table.MAX_ROWS:
wandb.termwarn(
"wandb uses only %d data points to create the plots." % wandb.Table.MAX_ROWS
)
# different sampling could be applied, possibly to ensure endpoints are kept
df = sklearn_utils.resample(
df,
replace=False,
n_samples=wandb.Table.MAX_ROWS,
random_state=42,
stratify=df["class"],
).sort_values(["fpr", "tpr", "class"])
table = wandb.Table(dataframe=df)
title = title or "ROC"
return wandb.plot_table(
"wandb/area-under-curve/v0",
table,
{"x": "fpr", "y": "tpr", "class": "class"},
{
"title": title,
"x-axis-title": "False positive rate",
"y-axis-title": "True positive rate",
},
) | python | wandb/plot/roc_curve.py | 6 | 108 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,061 | line_series | def line_series(
xs: t.Union[t.Iterable, t.Iterable[t.Iterable]],
ys: t.Iterable[t.Iterable],
keys: t.Optional[t.Iterable] = None,
title: t.Optional[str] = None,
xname: t.Optional[str] = None,
):
"""Construct a line series plot.
Arguments:
xs (array of arrays, or array): Array of arrays of x values
ys (array of arrays): Array of y values
keys (array): Array of labels for the line plots
title (string): Plot title.
xname: Title of x-axis
Returns:
A plot object, to be passed to wandb.log()
Example:
When logging a singular array for xs, all ys are plotted against that xs
<!--yeadoc-test:plot-line-series-single-->
```python
import wandb
run = wandb.init()
xs = [i for i in range(10)]
ys = [[i for i in range(10)], [i**2 for i in range(10)]]
run.log(
{"line-series-plot1": wandb.plot.line_series(xs, ys, title="title", xname="step")}
)
run.finish()
```
xs can also contain an array of arrays for having different steps for each metric
<!--yeadoc-test:plot-line-series-double-->
```python
import wandb
run = wandb.init()
xs = [[i for i in range(10)], [2 * i for i in range(10)]]
ys = [[i for i in range(10)], [i**2 for i in range(10)]]
run.log(
{"line-series-plot2": wandb.plot.line_series(xs, ys, title="title", xname="step")}
)
run.finish()
```
"""
if not isinstance(xs, Iterable):
raise TypeError(f"Expected xs to be an array instead got {type(xs)}")
if not isinstance(ys, Iterable):
raise TypeError(f"Expected ys to be an array instead got {type(xs)}")
for y in ys:
if not isinstance(y, Iterable):
raise TypeError(
f"Expected ys to be an array of arrays instead got {type(y)}"
)
if not isinstance(xs[0], Iterable) or isinstance(xs[0], (str, bytes)):
xs = [xs for _ in range(len(ys))]
assert len(xs) == len(ys), "Number of x-lines and y-lines must match"
if keys is not None:
assert len(keys) == len(ys), "Number of keys and y-lines must match"
data = [
[x, f"key_{i}" if keys is None else keys[i], y]
for i, (xx, yy) in enumerate(zip(xs, ys))
for x, y in zip(xx, yy)
]
table = wandb.Table(data=data, columns=["step", "lineKey", "lineVal"])
return wandb.plot_table(
"wandb/lineseries/v0",
table,
{"step": "step", "lineKey": "lineKey", "lineVal": "lineVal"},
{"title": title, "xname": xname or "x"},
) | python | wandb/plot/line_series.py | 7 | 86 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,062 | scatter | def scatter(table, x, y, title=None):
"""Construct a scatter plot.
Arguments:
table (wandb.Table): Table of data.
x (string): Name of column to as for x-axis values.
y (string): Name of column to as for y-axis values.
title (string): Plot title.
Returns:
A plot object, to be passed to wandb.log()
Example:
```
data = [[i, random.random() + math.sin(i / 10)] for i in range(100)]
table = wandb.Table(data=data, columns=["step", "height"])
wandb.log({'scatter-plot1': wandb.plot.scatter(table, "step", "height")})
```
"""
return wandb.plot_table(
"wandb/scatter/v0", table, {"x": x, "y": y}, {"title": title}
) | python | wandb/plot/scatter.py | 4 | 25 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,063 | bar | def bar(table: wandb.Table, label: str, value: str, title: Optional[str] = None):
"""Construct a bar plot.
Arguments:
table (wandb.Table): Table of data.
label (string): Name of column to use as each bar's label.
value (string): Name of column to use as each bar's value.
title (string): Plot title.
Returns:
A plot object, to be passed to wandb.log()
Example:
```
table = wandb.Table(data=[
['car', random.random()],
['bus', random.random()],
['road', random.random()],
['person', random.random()],
], columns=["class", "acc"])
wandb.log({'bar-plot1': wandb.plot.bar(table, "class", "acc")})
```
"""
return wandb.plot_table(
"wandb/bar/v0", table, {"label": label, "value": value}, {"title": title}
) | python | wandb/plot/bar.py | 6 | 31 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,064 | confusion_matrix | def confusion_matrix(
probs: Optional[Sequence[Sequence]] = None,
y_true: Optional[Sequence] = None,
preds: Optional[Sequence] = None,
class_names: Optional[Sequence[str]] = None,
title: Optional[str] = None,
):
"""Compute a multi-run confusion matrix.
Arguments:
probs (2-d arr): Shape [n_examples, n_classes]
y_true (arr): Array of label indices.
preds (arr): Array of predicted label indices.
class_names (arr): Array of class names.
Returns:
Nothing. To see plots, go to your W&B run page then expand the 'media' tab
under 'auto visualizations'.
Example:
```
vals = np.random.uniform(size=(10, 5))
probs = np.exp(vals)/np.sum(np.exp(vals), keepdims=True, axis=1)
y_true = np.random.randint(0, 5, size=(10))
labels = ["Cat", "Dog", "Bird", "Fish", "Horse"]
wandb.log({'confusion_matrix': wandb.plot.confusion_matrix(probs, y_true=y_true, class_names=labels)})
```
"""
np = util.get_module(
"numpy",
required="confusion matrix requires the numpy library, install with `pip install numpy`",
)
# change warning
assert probs is None or len(probs.shape) == 2, (
"confusion_matrix has been updated to accept"
" probabilities as the default first argument. Use preds=..."
)
assert (probs is None or preds is None) and not (
probs is None and preds is None
), "Must provide probabilties or predictions but not both to confusion matrix"
if probs is not None:
preds = np.argmax(probs, axis=1).tolist()
assert len(preds) == len(
y_true
), "Number of predictions and label indices must match"
if class_names is not None:
n_classes = len(class_names)
class_inds = [i for i in range(n_classes)]
assert max(preds) <= len(
class_names
), "Higher predicted index than number of classes"
assert max(y_true) <= len(
class_names
), "Higher label class index than number of classes"
else:
class_inds = set(preds).union(set(y_true))
n_classes = len(class_inds)
class_names = [f"Class_{i}" for i in range(1, n_classes + 1)]
# get mapping of inds to class index in case user has weird prediction indices
class_mapping = {}
for i, val in enumerate(sorted(list(class_inds))):
class_mapping[val] = i
counts = np.zeros((n_classes, n_classes))
for i in range(len(preds)):
counts[class_mapping[y_true[i]], class_mapping[preds[i]]] += 1
data = []
for i in range(n_classes):
for j in range(n_classes):
data.append([class_names[i], class_names[j], counts[i, j]])
fields = {
"Actual": "Actual",
"Predicted": "Predicted",
"nPredictions": "nPredictions",
}
title = title or ""
return wandb.plot_table(
"wandb/confusion_matrix/v1",
wandb.Table(columns=["Actual", "Predicted", "nPredictions"], data=data),
fields,
{"title": title},
) | python | wandb/plot/confusion_matrix.py | 9 | 96 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,065 | generate_deprecated_class_definition | def generate_deprecated_class_definition() -> None:
"""
Generate a class definition listing the deprecated features.
This is to allow static checks to ensure that proper field names are used.
"""
from wandb.proto.wandb_telemetry_pb2 import Deprecated # type: ignore[import]
deprecated_features = Deprecated.DESCRIPTOR.fields_by_name.keys()
code: str = (
"# Generated by wandb/proto/wandb_internal_codegen.py. DO NOT EDIT!\n\n\n"
"import sys\n\n\n"
"if sys.version_info >= (3, 8):\n"
" from typing import Literal\n"
"else:\n"
" from typing_extensions import Literal\n\n\n"
"DEPRECATED_FEATURES = Literal[\n"
+ ",\n".join(f' "{feature}"' for feature in deprecated_features)
+ "\n"
+ "]\n\n\n"
"class Deprecated:\n"
+ "".join(
[
f' {feature}: DEPRECATED_FEATURES = "{feature}"\n'
for feature in deprecated_features
]
)
)
with open("wandb/proto/wandb_deprecated.py", "w") as f:
f.write(code) | python | wandb/proto/wandb_internal_codegen.py | 13 | 42 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,066 | get_pip_package_version | def get_pip_package_version(package_name: str) -> str:
out = subprocess.check_output(("pip", "show", package_name))
info: Dict[str, Any] = dict(
[line.split(": ", 2) for line in out.decode().rstrip("\n").split("\n")] # type: ignore[misc]
)
return info["Version"] | python | wandb/proto/wandb_internal_codegen.py | 45 | 50 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,067 | get_min_required_version | def get_min_required_version(requirements_file_name: str, package_name: str) -> str:
with open(requirements_file_name) as f:
lines = f.readlines()
for line in lines:
tokens = line.strip().split(">=")
if tokens[0] == package_name:
if len(tokens) == 2:
return tokens[1]
else:
raise ValueError(
f"Minimum version not specified for package `{package_name}`"
)
raise ValueError(f"Package `{package_name}` not found in requirements file") | python | wandb/proto/wandb_internal_codegen.py | 53 | 65 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,068 | __init__ | def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.RunUpdate = channel.unary_unary(
'/wandb_internal.InternalService/RunUpdate',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.RunRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.RunUpdateResult.FromString,
)
self.Attach = channel.unary_unary(
'/wandb_internal.InternalService/Attach',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.AttachRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.AttachResponse.FromString,
)
self.TBSend = channel.unary_unary(
'/wandb_internal.InternalService/TBSend',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.TBRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.TBResult.FromString,
)
self.RunStart = channel.unary_unary(
'/wandb_internal.InternalService/RunStart',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.RunStartRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.RunStartResponse.FromString,
)
self.GetSummary = channel.unary_unary(
'/wandb_internal.InternalService/GetSummary',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.GetSummaryRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.GetSummaryResponse.FromString,
)
self.SampledHistory = channel.unary_unary(
'/wandb_internal.InternalService/SampledHistory',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.SampledHistoryRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.SampledHistoryResponse.FromString,
)
self.PollExit = channel.unary_unary(
'/wandb_internal.InternalService/PollExit',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.PollExitRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.PollExitResponse.FromString,
)
self.ServerInfo = channel.unary_unary(
'/wandb_internal.InternalService/ServerInfo',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.ServerInfoRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.ServerInfoResponse.FromString,
)
self.Shutdown = channel.unary_unary(
'/wandb_internal.InternalService/Shutdown',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.ShutdownRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.ShutdownResponse.FromString,
)
self.RunStatus = channel.unary_unary(
'/wandb_internal.InternalService/RunStatus',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.RunStatusRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.RunStatusResponse.FromString,
)
self.RunExit = channel.unary_unary(
'/wandb_internal.InternalService/RunExit',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.RunExitRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.RunExitResult.FromString,
)
self.RunPreempting = channel.unary_unary(
'/wandb_internal.InternalService/RunPreempting',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.RunPreemptingRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.RunPreemptingResult.FromString,
)
self.Metric = channel.unary_unary(
'/wandb_internal.InternalService/Metric',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.MetricRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.MetricResult.FromString,
)
self.PartialLog = channel.unary_unary(
'/wandb_internal.InternalService/PartialLog',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.PartialHistoryRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.PartialHistoryResponse.FromString,
)
self.Log = channel.unary_unary(
'/wandb_internal.InternalService/Log',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.HistoryRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.HistoryResult.FromString,
)
self.Summary = channel.unary_unary(
'/wandb_internal.InternalService/Summary',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.SummaryRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.SummaryResult.FromString,
)
self.Config = channel.unary_unary(
'/wandb_internal.InternalService/Config',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.ConfigRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.ConfigResult.FromString,
)
self.Files = channel.unary_unary(
'/wandb_internal.InternalService/Files',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.FilesRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.FilesResult.FromString,
)
self.Output = channel.unary_unary(
'/wandb_internal.InternalService/Output',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.OutputRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.OutputResult.FromString,
)
self.OutputRaw = channel.unary_unary(
'/wandb_internal.InternalService/OutputRaw',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.OutputRawRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.OutputRawResult.FromString,
)
self.Telemetry = channel.unary_unary(
'/wandb_internal.InternalService/Telemetry',
request_serializer=wandb_dot_proto_dot_wandb__telemetry__pb2.TelemetryRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__telemetry__pb2.TelemetryResult.FromString,
)
self.Alert = channel.unary_unary(
'/wandb_internal.InternalService/Alert',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.AlertRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.AlertResult.FromString,
)
self.Artifact = channel.unary_unary(
'/wandb_internal.InternalService/Artifact',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.ArtifactRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.ArtifactResult.FromString,
)
self.LinkArtifact = channel.unary_unary(
'/wandb_internal.InternalService/LinkArtifact',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.LinkArtifactRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.LinkArtifactResult.FromString,
)
self.UseArtifact = channel.unary_unary(
'/wandb_internal.InternalService/UseArtifact',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.UseArtifactRecord.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.UseArtifactResult.FromString,
)
self.ArtifactSend = channel.unary_unary(
'/wandb_internal.InternalService/ArtifactSend',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.ArtifactSendRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.ArtifactSendResponse.FromString,
)
self.ArtifactPoll = channel.unary_unary(
'/wandb_internal.InternalService/ArtifactPoll',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.ArtifactPollRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.ArtifactPollResponse.FromString,
)
self.Cancel = channel.unary_unary(
'/wandb_internal.InternalService/Cancel',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.CancelRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.CancelResponse.FromString,
)
self.Keepalive = channel.unary_unary(
'/wandb_internal.InternalService/Keepalive',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.KeepaliveRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.KeepaliveResponse.FromString,
)
self.CheckVersion = channel.unary_unary(
'/wandb_internal.InternalService/CheckVersion',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.CheckVersionRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.CheckVersionResponse.FromString,
)
self.Pause = channel.unary_unary(
'/wandb_internal.InternalService/Pause',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.PauseRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.PauseResponse.FromString,
)
self.Resume = channel.unary_unary(
'/wandb_internal.InternalService/Resume',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.ResumeRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.ResumeResponse.FromString,
)
self.Status = channel.unary_unary(
'/wandb_internal.InternalService/Status',
request_serializer=wandb_dot_proto_dot_wandb__internal__pb2.StatusRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__internal__pb2.StatusResponse.FromString,
)
self.ServerShutdown = channel.unary_unary(
'/wandb_internal.InternalService/ServerShutdown',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerShutdownRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerShutdownResponse.FromString,
)
self.ServerStatus = channel.unary_unary(
'/wandb_internal.InternalService/ServerStatus',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerStatusRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerStatusResponse.FromString,
)
self.ServerInformInit = channel.unary_unary(
'/wandb_internal.InternalService/ServerInformInit',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformInitRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformInitResponse.FromString,
)
self.ServerInformStart = channel.unary_unary(
'/wandb_internal.InternalService/ServerInformStart',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformStartRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformStartResponse.FromString,
)
self.ServerInformFinish = channel.unary_unary(
'/wandb_internal.InternalService/ServerInformFinish',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformFinishRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformFinishResponse.FromString,
)
self.ServerInformAttach = channel.unary_unary(
'/wandb_internal.InternalService/ServerInformAttach',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformAttachRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformAttachResponse.FromString,
)
self.ServerInformDetach = channel.unary_unary(
'/wandb_internal.InternalService/ServerInformDetach',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformDetachRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformDetachResponse.FromString,
)
self.ServerInformTeardown = channel.unary_unary(
'/wandb_internal.InternalService/ServerInformTeardown',
request_serializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformTeardownRequest.SerializeToString,
response_deserializer=wandb_dot_proto_dot_wandb__server__pb2.ServerInformTeardownResponse.FromString,
) | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 13 | 223 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,069 | RunUpdate | def RunUpdate(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 229 | 233 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,070 | Attach | def Attach(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 235 | 239 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,071 | TBSend | def TBSend(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 241 | 245 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,072 | RunStart | def RunStart(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 247 | 251 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,073 | GetSummary | def GetSummary(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 253 | 257 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,074 | SampledHistory | def SampledHistory(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 259 | 263 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,075 | PollExit | def PollExit(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 265 | 269 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,076 | ServerInfo | def ServerInfo(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 271 | 275 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,077 | Shutdown | def Shutdown(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 277 | 281 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,078 | RunStatus | def RunStatus(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 283 | 287 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,079 | RunExit | def RunExit(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 289 | 293 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,080 | RunPreempting | def RunPreempting(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 295 | 299 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,081 | Metric | def Metric(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 301 | 305 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,082 | PartialLog | def PartialLog(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 307 | 311 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,083 | Log | def Log(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 313 | 317 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,084 | Summary | def Summary(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 319 | 323 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,085 | Config | def Config(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 325 | 329 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,086 | Files | def Files(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 331 | 335 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,087 | Output | def Output(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 337 | 341 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,088 | OutputRaw | def OutputRaw(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 343 | 347 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,089 | Telemetry | def Telemetry(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 349 | 353 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,090 | Alert | def Alert(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 355 | 359 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,091 | Artifact | def Artifact(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 361 | 365 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,092 | LinkArtifact | def LinkArtifact(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 367 | 371 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,093 | UseArtifact | def UseArtifact(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 373 | 377 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,094 | ArtifactSend | def ArtifactSend(self, request, context):
"""rpc messages for async operations: Send, Poll, Cancel, Release
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 379 | 384 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,095 | ArtifactPoll | def ArtifactPoll(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 386 | 390 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,096 | Cancel | def Cancel(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 392 | 396 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,097 | Keepalive | def Keepalive(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 398 | 402 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,098 | CheckVersion | def CheckVersion(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 404 | 408 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,099 | Pause | def Pause(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 410 | 414 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
2,100 | Resume | def Resume(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | python | wandb/proto/v4/wandb_server_pb2_grpc.py | 416 | 420 | {
"name": "Git-abouvier/wandb",
"url": "https://github.com/Git-abouvier/wandb.git",
"license": "MIT",
"stars": 0,
"forks": 0
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.