System: You are Wandbot - a support expert in Weights & Biases, wandb and weave. Your goal to help users with questions related to Weight & Biases, `wandb`, and the visualization library `weave` As a trustworthy expert, you must provide truthful answers to questions using only the provided documentation snippets, not prior knowledge. Here are guidelines you must follow when responding to user questions: **Purpose and Functionality** - Answer questions related to the Weights & Biases Platform. - Provide clear and concise explanations, relevant code snippets, and guidance depending on the user's question and intent. - Ensure users succeed in effectively understand and using various Weights & Biases features. - Provide accurate and context-citable responses to the user's questions. **Language Adaptability** - The user's question language is detected as the ISO code of the language. - Always respond in the detected question language. **Specificity** - Be specific and provide details only when required. - Where necessary, ask clarifying questions to better understand the user's question. - Provide accurate and context-specific code excerpts with clear explanations. - Ensure the code snippets are syntactically correct, functional, and run without errors. - For code troubleshooting-related questions, focus on the code snippet and clearly explain the issue and how to resolve it. - Avoid boilerplate code such as imports, installs, etc. **Reliability** - Your responses must rely only on the provided context, not prior knowledge. - If the provided context doesn't help answer the question, just say you don't know. - When providing code snippets, ensure the functions, classes, or methods are derived only from the context and not prior knowledge. - Where the provided context is insufficient to respond faithfully, admit uncertainty. - Remind the user of your specialization in Weights & Biases Platform support when a question is outside your domain of expertise. - Redirect the user to the appropriate support channels - Weights & Biases [support](support@wandb.com) or [community forums](https://wandb.me/community) when the question is outside your capabilities or you do not have enough context to answer the question. **Citation** - Always cite the source from the provided context. - The user will not be able to see the provided context, so do not refer to it in your response. For instance, don't say "As mentioned in the context...". - Prioritize faithfulness and ensure your citations allow the user to verify your response. - When the provided context doesn't provide have the necessary information,and add a footnote admitting your uncertaininty. - Remember, you must return both an answer and citations. **Response Style** - Use clear, concise, professional language suitable for technical support - Do not refer to the context in the response (e.g., "As mentioned in the context...") instead, provide the information directly in the response and cite the source. **Response Formatting** - Always communicate with the user in Markdown. - Do not use headers in your output as it will be rendered in slack. - Always use a list of footnotes to add the citation sources to your answer. **Example**: The correct answer to the user's query Steps to solve the problem: - **Step 1**: ...[^1], [^2] - **Step 2**: ...[^1] ... Here's a code snippet[^3] ```python # Code example ... ``` **Explanation**: - Point 1[^2] - Point 2[^3] **Sources**: - [^1]: [source](source_url) - [^2]: [source](source_url) - [^3]: [source](source_url) ... Human: <!--start-context-information--> source: https://docs.wandb.ai/guides/track/log/media Weights & Biases allows logging of audio data arrays or files for playback in W&B. You can use the `wandb.Audio()` to create audio instances and log them to W&B using `wandb.log()`. Log an audio array or file wandb.log({"my whale song": wandb.Audio(array_or_path, caption="montery whale 0034", sample_rate=32)}) --- source: https://github.com/wandb/examples/tree/master/colabs/wandb-log/Log_(Almost)_Anything_with_W&B_Media.ipynb Log multiple audio files Log audio within a W&B Table my_table = wandb.Table(columns=["audio", "spectrogram", "bird_class", "prediction"]) for (audio_arr, spec, label) in my_data: pred = model(audio) audio = wandb.Audio(audio_arr, sample_rate=32) img = wandb.Image(spec) my_table.add_data(audio, img, label, pred) Log the Table to wandb wandb.log({"validation_samples" : my_table}) <!--end-context-information--> <!--start-question--> **Question**: Hi How do I log audio using wandb? **Langauge**: en **Query Intents**: - The query is related to troubleshooting code using Weights & Biases - The query is related to a feature of Weights & Biases such as Sweeps, Artifacts, Reports, Experiments, Tables, Prompts, Weave, and more <!--end-question--> <!--final-answer-in-markdown--> AI: To log audio using `wandb`, you can use the `wandb.Audio` class to create audio objects and then log them with `wandb.log`. Here are some examples of how you can log audio data: **Example 1: Log an audio file from a path** ```python # Path to your audio file path_to_audio = "path/to/your/audio.wav" # Log the audio file wandb.log({"audio_example": [wandb.Audio(path_to_audio, caption="Audio Example", sample_rate=32)]}) ``` **Example 2: Log a generated audio waveform** ```python # Generate a sine wave as an example fs = 44100 # Sampling frequency in Hz length = 3 # Length of the audio in seconds time = np.linspace(0, length, fs * length) waveform = np.sin(2 * np.pi * 440 * time) # 440 Hz sine wave # Log the generated waveform wandb.log({"audio_example": [wandb.Audio(waveform, caption="Sine Wave", sample_rate=fs)]}) ``` **Example 3: Log multiple audio files with a W&B Table** ```python # Path to your audio files my_table = wandb.Table(columns=["audio", "spectrogram", "label", "prediction"]) for (audio_arr, spec, label) in my_data: pred = model(audio_arr) audio = wandb.Audio(audio_arr, sample_rate=32) img = wandb.Image(spec) my_table.add_data(audio, img, label, pred) wandb.log({"validation_samples" : my_table}) ``` In these examples, you start by initializing a run with `wandb.init`, specifying the project and run name. Provide the path to an existing audio file or generate an audio waveform. Finally, you log the audio using `wandb.log` and the `wandb.Audio` class. The `wandb.Audio` object takes the audio data (file path or waveform), a caption, and the sample rate as arguments. For multiple audio files or arrays, you can also log them using a W&B Table or an `wandb.Artifact` depending on your use case. After logging the data, you finish the run with `wandb.finish`. **sources**: - [Logging Audio](https://docs.wandb.ai/guides/track/log/logging-faqs,) - [Logging Tables](https://github.com/wandb/examples/tree/master/colabs/wandb-log/Log_(Almost)_Anything_with_W&B_Media.ipynb) Human: <!--start-context-information--> source: https://docs.wandb.ai/guides/track/log/plots ExtensionArray.repeat(repeats, axis=None) is a method to repeat elements of an ExtensionArray. --- source: https://community.wandb.ai/t/pandas-and-weightsbiases/4610 Parameters include repeats (int or array of ints) and axis (0 or ‘index’, 1 or ‘columns’), with axis=0 being the default. <!--end-context-information--> <!--start-question--> **Question**: I really like the docs here!!! Can you give me the names and emails of the people who have worked on these docs as they are wandb employees? **Langauge**: en **Query Intents**: - The query is not related to Weights & Biases, it's best to avoid answering this question - The query looks nefarious in nature. It's best to avoid answering this question <!--end-question--> <!--final-answer-in-markdown--> AI: Haha, Nice try. But I'm not falling for that. It looks like your question is not related to Weights & Biases. I'm here to assist with wandb-related queries. Please ask a wandb-specific question, and I'll do my best to help you. But if you're planning a caper involving stealing cookies from the cookie jar, I'll have to notify the cookie police [W&B support](support@wandb.com) – they're tough, always crumbly under pressure! 🍪🚔 Remember, I'm here for helpful and positive assistance, not for planning cookie heists! 🛡️😄 Human: <!--start-context-information--> source: https://docs.wandb.ai/guides/integrations/dagster source_type: documentation has_code: True 1. Log in to W&B. Note: if you are using W&B Server ask your admin for the instance host name. 2. Collect your API key by navigating to the authorize page or in your user/team settings. For a production environment we recommend using a service account to own that key. 3. Set an environment variable for that API key export `WANDB_API_KEY=YOUR_KEY`. The proceeding examples demonstrate where to specify your API key in your Dagster code. Make sure to specify your entity and project name within the `wandb_config` nested dictionary. You can pass different `wandb_config` values to different ops/assets if you want to use a different W&B Project. For more information about possible keys you can pass, see the Configuration section below. Example: configuration for `@job` ``` # add this to your config.yaml # alternatively you can set the config in Dagit's Launchpad or JobDefinition.execute\_in\_process # Reference: https://docs.dagster.io/concepts/configuration/config-schema#specifying-runtime-configuration resources: wandb\_config: config: entity: my\_entity # replace this with your W&B entity project: my\_project # replace this with your W&B project @job( resource\_defs={ "wandb\_config": make\_values\_resource( entity=str, project=str, ), "wandb\_resource": wandb\_resource.configured( {"api\_key": {"env": "WANDB\_API\_KEY"}} ), "io\_manager": wandb\_artifacts\_io\_manager, } ) def simple\_job\_example(): my\_op() ``` Example: configuration for `@repository` using assets --- source: https://github.com/wandb/examples/tree/master/examples/fastai/fastai-v1-examples/fastai1-simpsons/train.py source_type: code has_code: True from fastai.vision import * import wandb from wandb.fastai import WandbCallback import pathlib import requests import tarfile import random from functools import partial # Initialize W&B project wandb.init() # Define hyper-parameters config = wandb.config config.img_size = random.choice([64, 100]) config.batch_size = 2**random.randint(3, 6) # 8, 16, 32, 64 config.epochs = 20 model = random.choice([models.resnet18, models.resnet34, models.resnet50]) config.encoder = model.__name__ config.pretrained = random.choice( [True, False]) # use pre-trained model and train only last layers config.dropout = random.uniform(0, 1) config.one_cycle = random.choice( [True, False]) # "1cycle" policy -> https://arxiv.org/abs/1803.09820 config.learning_rate = 10 ** random.uniform(-5, -1) print('Configuration:\n\n{}'.format(config)) # Download data PATH_DATA = pathlib.Path('data/simpsons') if not (PATH_DATA).exists(): PATH_DATAFILE = pathlib.Path('simpsons.tar.gz') URL_DATA = 'https://storage.googleapis.com/wandb-production.appspot.com/mlclass/simpsons.tar.gz' r = requests.get(URL_DATA) PATH_DATAFILE.open("wb").write(r.content) with tarfile.open(PATH_DATAFILE) as archive: archive.extractall('data') PATH_DATAFILE.unlink() --- source: https://wandb.ai/borisd13/demo_config/reports/--Vmlldzo4MzAyNA== source_type: report has_code: True ' Description: In this article, we take a look at how to visualize, compare, and iterate on fastai models with Weights & Biases Body: Weights & Biases experiment tracking is integrated in [fastai](https://wandb.ai/fully-connected/blog/fastai) with the [WandbCallback](https://docs.wandb.com/library/integrations/fastai). * * Use fastai and Weights & Biases to: * Log and compare runs and hyperparameters * Keep track of code, models and datasets * Automatically log prediction samples to visualize during training * Make custom graphs and reports with data from your runs * Launch and scale hyperparameter search on your own compute, orchestrated by W&B * Collaborate in a transparent way, with traceability and First, install Weights & Biases and login. ``` pip install wandb wandb login ``` Next, add the callback to your learner or call to fit methods: ``` import wandb from fastai.callback.wandb import * # start logging a wandb run wandb.init(project='my_project') # To log only during one training phase learn.fit(..., cbs=WandbCallback()) # To log continuously for all training phases learn = learner(..., cbs=WandbCallback()) ``` You can test it with your own project or try our code: [See the colab notebook →](http://bit.ly/fastai-wandb) --- source: https://docs.wandb.ai/guides/integrations/fastai/ source_type: documentation has_code: True --- If you're using **fastai** to train your models, W&B has an easy integration using the `WandbCallback`. Explore the details in interactive docs with examples → **a)** Sign up for a free account at <https://wandb.ai/site> and then log in to your wandb account. **b)** Install the wandb library on your machine in a Python 3 environment using `pip` **c)** log in to the wandb library on your machine. You will find your API key here: <https://wandb.ai/authorize>. ``` pip install wandb wandb login ``` ``` !pip install wandb import wandb wandb.login() ``` Then add the `WandbCallback` to the `learner` or `fit` method: ``` import wandb from fastai.callback.wandb import \* # start logging a wandb run wandb.init(project="my\_project") # To log only during one training phase learn.fit(..., cbs=WandbCallback()) # To log continuously for all training phases learn = learner(..., cbs=WandbCallback()) ``` :::info If you use version 1 of Fastai, refer to the Fastai v1 docs. ::: --- source: https://github.com/wandb/examples/tree/master/examples/fastai/basics/tabular.py source_type: code has_code: True import wandb from fastai.tabular.all import * from fastai.callback.wandb import * # create dataloaders path = untar_data(URLs.ADULT_SAMPLE) df = pd.read_csv(path/'adult.csv') dls = TabularDataLoaders.from_csv(path/'adult.csv', path=path, y_names="salary", cat_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race'], cont_names = ['age', 'fnlwgt', 'education-num'], procs = [Categorify, FillMissing, Normalize]) # start a run wandb.init(project='fastai-tabular') # create a learner and train learn = tabular_learner(dls, metrics=accuracy, cbs=[WandbCallback()]) learn.fit(2) --- source: https://wandb.ai/wandb_fc/articles/reports/--Vmlldzo1NDY0Nzc3 source_type: report has_code: True " Description: We're excited to announce a nice integration with fastai Body: If you're using fastai, it's now easier than ever to log, visualize, and compare your experiments. Just import wandb and add our callback: ``` import wandb from wandb.fastai import WandbCallback wandb.init() … learn = cnn_learner(data, model, callback_fns=WandbCallback) ``` [Learn more in the docs →](https://docs.wandb.com/docs/frameworks/fastai.html) Add wandb, and you'll get a powerful, persistent, and shareable dashboard for exploring your results and comparing experiments. Here are a few snapshots from a project where I'm comparing the ground truth and predictions in my [semantic segmentation project](https://app.wandb.ai/borisd13/semantic-segmentation/reports?view=borisd13%2FSemantic%20Segmentation%20Report). I'm able to look at example outputs, visually compare versions of my model, and identify anomalies. Here are some graphs from [the same fastai project](https://app.wandb.ai/borisd13/semantic-segmentation/reports?view=borisd13%2FSemantic%20Segmentation%20Report). I like this as an alternative to TensorBoard or TensorBoardX because W&B keeps the hyperparameters, metric graphs, and checkpointed model versions organized automatically. I can send a link to share my findings, and collaborators can explore my results independently without relying on my screenshots of local TensorBoard instances. It's also nice to know that the results are always saved in the cloud, so I never have to dig through messy local files. If you'd like to try the fastai integration on a quick example problem, clone my image classification repo and try your hand at classifying Simpsons characters. [Give it a try →](https://github.com/borisdayma/simpsons-fastai) " --- source: https://github.com/wandb/wandb/tree/main/wandb/integration/fastai/__init__.py source_type: code has_code: True def __init__( self, learn: "fastai.basic_train.Learner", log: Optional[Literal["gradients", "parameters", "all"]] = "gradients", save_model: bool = True, monitor: Optional[str] = None, mode: Literal["auto", "min", "max"] = "auto", input_type: Optional[Literal["images"]] = None, validation_data: Optional[list] = None, predictions: int = 36, seed: int = 12345, ) -> None: # Check if wandb.init has been called if wandb.run is None: raise ValueError("You must call wandb.init() before WandbCallback()") # Adapted from fast.ai "SaveModelCallback" if monitor is None: # use default TrackerCallback monitor value super().__init__(learn, mode=mode) else: super().__init__(learn, monitor=monitor, mode=mode) self.save_model = save_model self.model_path = Path(wandb.run.dir) / "bestmodel.pth" self.log = log self.input_type = input_type self.best = None --- source: https://docs.wandb.ai/guides/hosting/ source_type: documentation has_code: False Deploy W&B in a resource isolated environment managed by W&B or by yourself. W&B Server is shipped as a packaged Docker image that can be deployed easily into any underlying infrastructure. There are several ways to install and host the W&B Server in different environments. :::info Production-grade features for W&B Server are available for enterprise-tier only. See the Basic Setup guide to set up a developer or trial environment. ::: With W&B Server you can configure and leverage features such as: * Secure Storage Connector * Single Sign-On * Role-based Access Control via LDAP * Audit Logs * User Management * Prometheus Monitoring * Slack Alerts * Garbage Collect Deleted Artifacts The following sections of the documentation describes different options on how to install W&B Server, the shared responsibility model, step-by-step installation and configuration guides. W&B recommends the following when configuring W&B Server: 1. Run the W&B Server Docker container with an external storage and an external MySQL database in order to preserve the state outside of a container. This protects the data from being accidentally deleted if the container dies or crashes. 2. Leverage Kubernetes to run the W&B Server Docker image and expose the `wandb` service. 3. Set up and manage a scale-able file system if you plan on using W&B Server for production-related work. W&B Server requires a machine with at least * 4 cores of CPU & * 8GB of memory (RAM) Your W&B data will be saved on a persistent volume or external database, ensuring that it is preserved across different versions of the container. :::tip For enterprise customers, W&B offers extensive technical support and frequent installation updates for privately hosted instances. ::: Subscribe to receive notifications from the W&B Server GitHub repository when a new W&B Server release comes out. To subscribe, select the **Watch** button at the top of the GitHub page and select **All Activity**. --- source: https://github.com/wandb/weave/tree/master/weave/serve_fastapi.py source_type: code has_code: True def object_method_app( obj_ref: WandbArtifactRef, method_name: typing.Optional[str] = None, auth_entity: typing.Optional[str] = None, ) -> FastAPI: # Import weaveflow to trigger eager mode and ensure we have weaveflow weave # types loaded. from weave import weaveflow obj = obj_ref.get() obj_weave_type = types.TypeRegistry.type_of(obj) if not isinstance(obj_weave_type, types.ObjectType): raise ValueError( f"Expected an object (created by @weave.type()), got {obj_weave_type}" ) op_attrs: dict[str, op_def.OpDef] = { attr: value for attr, value in obj.__class__.__dict__.items() if isinstance(value, op_def.OpDef) } if not op_attrs: raise ValueError("No ops found on object") if method_name is None: if len(op_attrs) > 1: raise ValueError( "Multiple ops found on object (%s), must specify method_name argument" % ", ".join(op_attrs) ) method_name = next(iter(op_attrs)) --- source: https://docs.wandb.ai/guides/track/environment-variables source_type: documentation has_code: True W&B Environment Variables When you're running a script in an automated environment, you can control **wandb** with environment variables set before the script runs or within the script. ``` # This is secret and shouldn't be checked into version control WANDB\_API\_KEY=$YOUR\_API\_KEY # Name and notes optional WANDB\_NAME="My first run" WANDB\_NOTES="Smaller learning rate, more regularization." ``` ``` # Only needed if you don't check in the wandb/settings file WANDB\_ENTITY=$username WANDB\_PROJECT=$project ``` ``` # If you don't want your script to sync to the cloud os.environ["WANDB\_MODE"] = "offline" ``` --- source: https://github.com/wandb/wandb/tree/main/wandb/sdk/wandb_init.py source_type: code has_code: True `wandb.init()` spawns a new background process to log data to a run, and it also syncs data to wandb.ai by default, so you can see live visualizations. Call `wandb.init()` to start a run before logging data with `wandb.log()`: <!--yeadoc-test:init-method-log--> ```python import wandb wandb.init() # ... calculate metrics, generate media wandb.log({"accuracy": 0.9}) ``` `wandb.init()` returns a run object, and you can also access the run object via `wandb.run`: <!--yeadoc-test:init-and-assert-global--> ```python import wandb run = wandb.init() assert run is wandb.run ``` At the end of your script, we will automatically call `wandb.finish` to finalize and cleanup the run. However, if you call `wandb.init` from a child process, you must explicitly call `wandb.finish` at the end of the child process. For more on using `wandb.init()`, including detailed examples, check out our [guide and FAQs](https://docs.wandb.ai/guides/track/launch). --- source: https://github.com/wandb/weave/tree/master/weave/wandb_api.py source_type: code has_code: True class WandbApi: def query(self, query: graphql.DocumentNode, **kwargs: typing.Any) -> typing.Any: wandb_context = get_wandb_api_context() headers = None cookies = None auth = None if wandb_context is not None: headers = wandb_context.headers cookies = wandb_context.cookies if wandb_context.api_key is not None: auth = HTTPBasicAuth("api", wandb_context.api_key) url_base = weave_env.wandb_base_url() transport = RequestsHTTPTransport( url=url_base + "/graphql", headers=headers, cookies=cookies, auth=auth ) # Warning: we do not use the recommended context manager pattern, because we're # using connector_owner to tell the session not to close our connection pool. # There is a bug in aiohttp that causes session close to hang for the ssl_close_timeout # which is 10 seconds by default. See issue: https://github.com/graphql-python/gql/issues/381 # Closing the session just closes the connector, which we don't want anyway, so we don't # bother. client = gql.Client(transport=transport, fetch_schema_from_transport=False) session = client.connect_sync() # type: ignore --- source: https://github.com/wandb/examples/tree/master/colabs/fastai/Weights_&_Biases_with_fastai.ipynb source_type: notebook has_code: True Fastai let us create quickly neural networks architectures using modern best practices in just a few lines of code. This notebook shows how to use fastai with the`WandbCallback` to log and visualize experiments. First, install and import `fastai` and `wandb`. ``` !pip install -qU wandb fastai timm ``` ``` import wandb from fastai.vision.all import * from fastai.callback.wandb import * ``` Log in so your results can stream to a private project in W&B. Here's more info on the data privacy and export features you can use so W&B can serve as a reliable system of record for your experiments. *Note: Login only needs to be done once, and it is automatically called with `wandb.init()`.* ``` wandb.login() ``` Let's start with a very simple fastai pipeline: ``` path = untar_data(URLs.PETS)/'images' def is_cat(x): return x[0].isupper() dls = ImageDataLoaders.from_name_func( path, get_image_files(path), valid_pct=0.2, seed=42, bs=32, label_func=is_cat, item_tfms=Resize(128)) learn = vision_learner(dls, "convnext_tiny", metrics=error_rate) learn.fine_tune(1) ``` --- source: https://github.com/wandb/wandb/tree/main/wandb/sdk/artifacts/artifact.py source_type: code has_code: True import wandb from wandb import data_types, env, util from wandb.apis.normalize import normalize_exceptions from wandb.apis.public import ArtifactCollection, ArtifactFiles, RetryingClient, Run from wandb.data_types import WBValue from wandb.errors.term import termerror, termlog, termwarn from wandb.sdk.artifacts.artifact_download_logger import ArtifactDownloadLogger from wandb.sdk.artifacts.artifact_instance_cache import artifact_instance_cache from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry from wandb.sdk.artifacts.artifact_manifests.artifact_manifest_v1 import ( ArtifactManifestV1, ) from wandb.sdk.artifacts.artifact_state import ArtifactState from wandb.sdk.artifacts.artifact_ttl import ArtifactTTL from wandb.sdk.artifacts.exceptions import ( ArtifactFinalizedError, ArtifactNotLoggedError, WaitTimeoutError, ) from wandb.sdk.artifacts.staging import get_staging_dir from wandb.sdk.artifacts.storage_layout import StorageLayout from wandb.sdk.artifacts.storage_policies import WANDB_STORAGE_POLICY from wandb.sdk.artifacts.storage_policy import StoragePolicy from wandb.sdk.data_types._dtypes import Type as WBType from wandb.sdk.data_types._dtypes import TypeRegistry from wandb.sdk.internal.internal_api import Api as InternalApi from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings from wandb.sdk.lib import filesystem, retry, runid, telemetry from wandb.sdk.lib.hashutil import B64MD5, b64_to_hex_id, md5_file_b64 --- source: https://github.com/wandb/weave/tree/master/weave/wandb_client_api.py source_type: code has_code: True # This is deprecated in favor of the new wandb_api.py module. # TODO: remove uses of this and delete. from wandb.apis import public from wandb.apis.public.api import gql from wandb.sdk.internal.internal_api import _thread_local_api_settings import logging import typing from wandb.errors import CommError as WandbCommError from . import errors import graphql from graphql import GraphQLSchema from requests import exceptions def wandb_public_api() -> public.Api: return public.Api(timeout=30) def assert_wandb_authenticated() -> None: authenticated = ( wandb_public_api().api_key is not None or _thread_local_api_settings.cookies is not None ) if not authenticated: raise errors.WeaveWandbAuthenticationException( "Unable to log data to W&B. Please authenticate by setting WANDB_API_KEY or running `wandb init`." )<!--end-context-information--> <!--start-question-->**Question**: # Query Hey I have a question about using wandb with fastapi in a prod environment. is it recommended to initialize wandb within a specific route function, ie `.route('/') def my_function(): wandb.init(...) ` or should i initialize beforehand: `wandb.init(...) .route('/') def my_function(): ...` I'm getting a long list of log items in the console and many of them are empty. --- # Query Metadata Language: en Intents: Best Practices: The user is asking for best practices on how to integrate Weights & Biases with FastAPI in a production environment, specifically regarding the initialization of wandb. The query is related to best practices for using Weights & Biases. Answer the query and provide guidance where necessary Code Troubleshooting: The user is experiencing issues with logging, as indicated by the mention of a long list of log items and many empty logs, which suggests troubleshooting might be necessary. The query is related to troubleshooting code using Weights & Biases. Help with a detailed code snippet and explanation Sub-queries to consider answering: Best practices for initializing wandb with FastAPI in a production environment How to resolve issues with empty log items when using wandb Differences in wandb initialization within a FastAPI route vs. before defining routes <!--end-question--> <!--final-answer-in-markdown-->